samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/terminal_ui/attached_loop.rb

@@ -12,6 +12,7 @@ require_relative "reline_seam"
 require_relative "../bridge_client"
 require_relative "../log"
 require_relative "../context_note"
+require_relative "../steer"
 require_relative "../model_profile"
 require_relative "../output_formatter"
 require_relative "../session_commands"
@@ -30,15 +31,7 @@ module Samagotchi
       include Formatting
       include InputSupport
 
-      STATS_COMMAND = "/stats"
-      RECAP_COMMAND = "/recap"
       PROMPT = "> "
-      # Detach and leave the worker up.
-      DETACH_COMMANDS = %w[/detach].freeze
-      # Detach and ask the worker to exit (bare `exit` too, as in the REPL).
-      EXIT_COMMANDS = %w[/exit /quit].freeze
-      # After an exit command: delete the session once the worker has gone.
-      DELETE_FLAG = "--delete"
       # How long /exit --delete waits for the worker to let go.
       DELETE_WAIT = 10
       # A second Ctrl-C at an empty idle prompt within this many seconds detaches.
@@ -82,11 +75,15 @@ module Samagotchi
       #   the first read (a new session with no -p, as the REPL)
       # @param clock [#call] monotonic seconds (the Ctrl-C detach window)
       # @param delete_session [#call] session id -> deletes it (/exit --delete)
+      # @param archive_session [#call] session id -> archives it (/archive);
+      #   SessionManager.archive_session's result
       def initialize(client:, screen:, client_id:, first_prompt: nil, first_command: nil, no_interrupt: false,
                      default_input: false, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
-                     delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) })
+                     delete_session: ->(id) { SessionManager.delete_session(id, stop: true, wait: DELETE_WAIT) },
+                     archive_session: ->(id) { SessionManager.archive_session(id, wait: DELETE_WAIT) })
         @client = client
         @delete_session = delete_session
+        @archive_session = archive_session
         @screen = screen
         @client_id = client_id
         @view = AttachedView.new(screen)
@@ -198,7 +195,7 @@ module Samagotchi
         # Another client's anytime command: its line now, before the cards
         # it shows (its command_ran comes when it's done).
         when :command_queued
-          @screen.commit(prompt_line(event[:client_id], event[:line])) if event[:anytime] && !own?(event[:client_id])
+          @screen.commit(prompt_line(event[:client_id], event[:line])) if event[:anytime] && !own?(event[:client_id]) && !event[:card]
         when :command_ran
           command_ran(event)
           return first_command_ran(event) if @first_command_id && event[:command_id] == @first_command_id
@@ -262,22 +259,26 @@ module Samagotchi
 
         text = line.strip
         return answer_question(text) if @question
-        # Before the continue offer: neither is an answer to it.
-        return submit(nil) if DETACH_COMMANDS.include?(text.downcase)
-        return exit_worker if exit_command?(text)
-        return exit_and_delete if exit_command?(text.delete_suffix(DELETE_FLAG).rstrip) && text.end_with?(" #{DELETE_FLAG}")
-        command = text.split(/\s+/, 2).first
+
+        # The terminal's own commands (SessionCommands registers them, the
+        # REPL reads the same words). Before the continue offer: the
+        # leaving ones are no answer to it.
+        local = command_registry.lookup_local(text)&.id
+        return submit(nil) if local == :detach
+        return SessionCommands.delete_on_exit?(text) ? exit_and_delete : exit_worker if local == :exit
+        return exit_and_archive if local == :archive
+
         if @continue_offer
-          return answer_continue(text) unless command_registry.command?(text) || [STATS_COMMAND, RECAP_COMMAND].include?(command)
+          return answer_continue(text) unless local || command_registry.command?(text)
 
           # Not an answer: the read left no echo, so show what ran.
           echo_answer(text)
         end
         return if text.empty?
 
-        if command == STATS_COMMAND
+        if local == :stats
           show_stats
-        elsif command == RECAP_COMMAND
+        elsif local == :recap
           show_recap
         elsif command_registry.command?(text)
           # The history keeps !cmds, as the REPL's does (prompts: #send_prompt).
@@ -306,8 +307,6 @@ module Samagotchi
         detach(exit_failed_line(e.message))
       end
 
-      def exit_command?(text) = EXIT_COMMANDS.include?(text.downcase) || text.casecmp?("exit")
-
       # /exit --delete: the worker exits as for /exit, then the session is
       # deleted. When the worker stays up (another UI, queued input, ...),
       # nothing is deleted.
@@ -329,6 +328,27 @@ module Samagotchi
         detach("Detached; the worker is stopping, but session #{id} was not deleted (#{e.message}): chi sessions delete #{id}")
       end
 
+      # /archive: the worker is asked to exit as for /exit, then the session
+      # is archived. A worker staying up for another UI (or reminders, a
+      # queued prompt) is stopped by the archive, as the web's archive
+      # stops it; a turn running refuses it. An empty session: the worker
+      # deletes it as it leaves.
+      def exit_and_archive
+        reply = @client.request_exit(client_id: @client_id)
+        id = @client.session_id
+        return detach("Detached; the session was empty, so it is discarded.") if reply.status == 200 && discards?(reply)
+        return detach("#{exit_line(reply)} Not archived.") unless [200, 409].include?(reply.status)
+
+        result = @archive_session.call(id)
+        return detach("Detached; the session was empty, so it is discarded.") if result[:discarded].include?(id)
+
+        detach("Detached; archived session #{id}. chi sessions list --archived finds it.")
+      rescue SystemCallError, IOError => e
+        detach("#{exit_failed_line(e.message)} Not archived.")
+      rescue SessionManager::ArchiveRefused, SessionManager::OwnedByTUI, ArgumentError => e
+        detach("Detached; session #{id} was not archived (#{e.message}). Re-attach with: chi --attach #{id}")
+      end
+
       def exit_line(reply)
         id = @client.session_id
         error = reply.json&.fetch("error", nil)
@@ -401,7 +421,7 @@ module Samagotchi
       end
 
       def command_ran(event)
-        @screen.commit(prompt_line(event[:client_id], event[:line])) unless own?(event[:client_id]) || event[:anytime]
+        @screen.commit(prompt_line(event[:client_id], event[:line])) unless own?(event[:client_id]) || event[:anytime] || event[:card]
         output = event[:output].to_s
         if output.empty?
           nil
@@ -469,12 +489,10 @@ module Samagotchi
 
       def send_prompt(text)
         persist_recent_history(text)
-        # #memory shorthand becomes words the model reads, as in the REPL.
-        prompt = normalize_model_input(text)
         images = attach_images(text)
         return if images.nil?
 
-        options = { prompt: prompt, client_id: @client_id }
+        options = { prompt: text, client_id: @client_id }
         options[:no_interrupt] = true if @no_interrupt
         options[:images] = images unless images.empty?
         reply = @client.post_turn(**options)
@@ -566,6 +584,13 @@ module Samagotchi
         # What was typed at the prompt waits for the question to close.
         @set_aside = @reader&.typed_text unless @question
         @question = QuestionPrompt.new(pending)
+        # An edit's diff goes above, into the scrollback, once per question
+        # (a join gets it from the snapshot and may get the event too).
+        unless @previewed_id == @question.id
+          @previewed_id = @question.id
+          preview = @question.preview_lines(paint: method(:paint))
+          @screen.commit(preview.join("\n")) unless preview.empty?
+        end
         # The prompt first, so the choices never show under the typed text.
         sync_prompt(keep_text: false)
         @screen.set_slot(:notes, @question.slot(paint: method(:paint)))
@@ -816,12 +841,15 @@ module Samagotchi
         # The id stays findable: the detach line and chi sessions list show it.
         Log.session_id = @client.session_id
         Log.info(:attached, "joined", session: @client.session_id, messages: exchange.size)
-        last_user = exchange.rindex { |m| m[:role].to_s == "user" }
+        last_user = exchange.rindex { |m| Steer.prompt?(m) }
         render_join_notes(messages)
         return unless last_user
 
         @screen.commit(prompt_line(nil, exchange[last_user][:content]))
         Array(exchange[last_user][:images]).each { |ref| @screen.commit(format_image_line(ref)) }
+        exchange[(last_user + 1)..].select { |m| Steer.steer?(m) }.each do |m|
+          @screen.commit(format_steer_line(source: m[:source], text: m[:content]))
+        end
         # The saved answer is raw: the latest keeps its thinking, and one may
         # be only a tool call.
         answer = exchange[(last_user + 1)..].reverse_each
@@ -834,7 +862,7 @@ module Samagotchi
       # The context notes that came since the last prompt (all of them in a
       # session with none), after the exchange the header shows.
       def render_join_notes(messages, after_exchange: false)
-        last_user = messages.rindex { |m| m[:role].to_s == "user" }
+        last_user = messages.rindex { |m| Steer.prompt?(m) }
         return if after_exchange != !last_user.nil?
 
         messages[(last_user ? last_user + 1 : 0)..].select { |m| ContextNote.note?(m) }.each do |m|
@@ -894,6 +922,7 @@ module Samagotchi
               @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 "hook_notice" then @screen.commit(EventRenderer.hook_notice_line(part))
           end
@@ -1029,8 +1058,8 @@ module Samagotchi
         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 == "ok" ? 32 : 31)}" \
-          "#{format_tool_image_suffix(part[:images])}"
+        "#{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

data/lib/samagotchi/terminal_ui/event_renderer.rb

@@ -55,14 +55,20 @@ module Samagotchi
         when :tool_call_started
           @tool_started_at[tool_call_key(event)] = @clock.call
           @view.tool_call_feedback_started(event)
+        when :used_memories_updated
+          @view.used_memories_updated(event) if @view.respond_to?(:used_memories_updated)
         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])
+          render_streamed_tool_activity(event[:activity], duration_ms: tool_duration_ms(event), images: event[:images],
+                                                          diff: event[:diff])
         when :generation_completed, :generation_cancelled, :tool_dispatch_started
           @view.generation_feedback_finished
         when :pending_input_merged
           render_merge(event)
+        when :empty_answer_retry
+          @view.finish_thinking_spinner
+          @view.print_line(@view.format_empty_retry_line(event))
         when :turn_completed
           render_turn_summary(event[:turn_summary]) if event[:turn_summary]
         when :guardrail_warning
@@ -101,7 +107,8 @@ module Samagotchi
       # @param event [Hash] :hook_notice event or a snapshot part with
       #   hook:, text:, level:
       def self.hook_notice_line(event)
-        label = event[:hook].to_s[/\(bundle (.+)\)\z/, 1] || "hook"
+        # chi's own notices name themselves with a bare word (thinking).
+        label = event[:hook].to_s[/\(bundle (.+)\)\z/, 1] || event[:hook].to_s[/\A[a-z][a-z0-9-]*\z/] || "hook"
         text = event[:text].to_s
         text = "warning: #{text}" if event[:level].to_s == "warn"
         "#{label}> #{text}"
@@ -146,23 +153,26 @@ module Samagotchi
         @view.print_line("iteration limit reached") if summary[:resumable]
       end
 
-# Steering merged into the running turn: the answer it follows first
-# (the turn summary shows only the last one), then the note.
-def render_merge(event)
-  @view.finish_thinking_spinner
-  @view.print_line(event[:answer]) unless event[:answer].to_s.strip.empty?
-  count = event[:count].to_i
-  @view.print_line("(#{count} message#{"s" unless count == 1} merged into the running turn)")
-end
+      # Steering merged into the running turn: the answer it follows first
+      # (the turn summary shows only the last one), then the note, then a
+      # line per plugin steer (none for a steer-only merge).
+      def render_merge(event)
+        @view.finish_thinking_spinner
+        @view.print_line(event[:answer]) unless event[:answer].to_s.strip.empty?
+        count = event[:count].to_i
+        @view.print_line("(#{count} message#{"s" unless count == 1} merged into the running turn)") if count.positive?
+        Array(event[:steers]).each { |steer| @view.print_line(@view.format_steer_line(source: steer[:source], text: steer[:text])) }
+      end
 
 private
 
-      def render_streamed_tool_activity(activity, duration_ms:, images: nil)
+      def render_streamed_tool_activity(activity, duration_ms:, images: nil, diff: nil)
         return if activity.nil?
 
         @streamed_tool_activity[tool_activity_key(activity)] += 1
         line = @view.format_tool_activity_line(activity, duration_ms: duration_ms)
         line += @view.format_tool_image_suffix(images) if images&.any?
+        line += @view.format_tool_diff_suffix(diff) if diff
         @view.print_line(line)
       end
 

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -13,9 +13,13 @@ module Samagotchi
         params = activity[:params].to_s.strip
         params_suffix = params.empty? ? "" : " #{paint(params, 90)}"
         status = activity[:status].to_s
-        status_color = status == "ok" ? 32 : 31
         elapsed_suffix = duration_ms.nil? ? "" : " (#{format_elapsed_duration(duration_ms)})"
-        "#{paint('tool>', 36)} #{activity[:action]} (#{activity[:tool]}#{params_suffix}): #{paint(status, status_color)}#{elapsed_suffix}"
+        "#{paint('tool>', 36)} #{activity[:action]} (#{activity[:tool]}#{params_suffix}): #{paint(status, status_color(status))}#{elapsed_suffix}"
+      end
+
+      # Green ok, yellow stopped (a wait the user's Stop ended), red the rest.
+      def status_color(status)
+        { "ok" => 32, "stopped" => 33 }.fetch(status, 31)
       end
 
       # "[image shot.png 1280×800 · ~1.3k tokens]", dim: a turn's image.
@@ -23,6 +27,21 @@ module Samagotchi
         paint("[image #{ImageRef.label(ImageStore.symbolize(ref))}]", 90)
       end
 
+      STEER_PREVIEW = 80
+
+      # "check-in> nudged: <text>", dim, one line cut: a plugin's steer
+      # (Steer) in the running turn or the join's last exchange.
+      def format_steer_line(source:, text:)
+        first = text.to_s.strip.split("\n").first.to_s
+        first = "#{first[0, STEER_PREVIEW - 1]}…" if first.length > STEER_PREVIEW || text.to_s.strip.include?("\n")
+        paint("#{source.to_s.empty? ? "plugin" : source}> nudged: #{first}", 90)
+      end
+
+      # "↻ empty answer, asking again (1/1)": the loop retries an empty answer.
+      def format_empty_retry_line(event)
+        paint("↻ empty answer, asking again (#{event[:attempt]}/#{event[:of]})", 90)
+      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) }
@@ -31,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
@@ -229,11 +257,11 @@ module Samagotchi
       def format_session_metrics(snapshot)
         return "(no metrics yet)" unless snapshot.is_a?(Hash)
 
-        # A symbol locally; a string when the snapshot came over the Bridge.
-        token_src = snapshot[:token_source]&.to_s
-        token_src_label = case token_src
+        tokens = snapshot[:tokens] || {}
+        token_src_label = case tokens[:source]
                           when "server" then "server-reported"
                           when "estimate" then "estimated (chars/4)"
+                          when "mixed" then "server-reported, some estimated"
                           else "n/a"
                           end
 
@@ -245,13 +273,17 @@ module Samagotchi
           lines << "  by tool:        #{by_tool.map { |k, v| "#{k}=#{v}" }.join(", ")}"
         end
         lines << "iterations:       #{snapshot[:iterations_total]}"
-        lines << "tokens in/out:    #{snapshot[:tokens_in]}/#{snapshot[:tokens_out]} (total #{snapshot[:tokens_total]}, #{token_src_label})"
+        # Summed over every request: each prompt is sent in full again.
+        lines << "tokens in/out:    #{tokens[:prompt_sum].to_i}/#{tokens[:completion_sum].to_i} (all requests, #{token_src_label})"
         lines << "gen latency (ms): #{snapshot[:gen_latency_ms]}"
         lines << "cancellations:    #{snapshot[:cancellations]}"
         lines << "retries:          #{snapshot[:retries]}"
-        if snapshot[:context_window_tokens]
-          lines << "context window:   #{snapshot[:context_window_tokens]} tokens (#{snapshot[:context_window_source]})"
+        context = snapshot[:context] || {}
+        if context[:used_tokens]
+          pct = context[:window_tokens].to_i.positive? ? format(" (%.1f%%)", context[:used_tokens] * 100.0 / context[:window_tokens]) : ""
+          lines << "context used:     #{context[:used_tokens]} tokens#{pct}"
         end
+        lines << "context window:   #{context[:window_tokens]} tokens (#{context[:window_source]})" if context[:window_tokens]
         lines << "prompt profile:   #{snapshot[:profile]} (#{snapshot[:profile_source]})" if snapshot[:profile]
         if snapshot[:served_model]
           asked = snapshot[:served_model_for]

data/lib/samagotchi/terminal_ui/input_support.rb

@@ -11,10 +11,10 @@ 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.
@@ -204,21 +204,6 @@ 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
         return explicit unless explicit.empty?
@@ -240,7 +225,10 @@ module Samagotchi
         nil
       end
 
+      # A scratch session keeps nothing, its typed lines neither.
       def persist_recent_history(input)
+        return if @scratch
+
         entries = normalize_history_entries(load_history_entries_from_disk)
         entries << input
         trimmed_entries = entries.last(PROMPT_HISTORY_LIMIT)

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