samagotchi 0.3.0 → 0.4.0

data/lib/samagotchi/terminal_ui.rb

@@ -47,15 +47,7 @@ module Samagotchi
     include Formatting
     include InputSupport
 
-    AGENT_DESCRIPTION_FILE = "AGENT.md"
-    SKIP_AGENT_DESCRIPTION_ENV = "SAMAGOTCHI_SKIP_AGENT_MD"
-    STATS_COMMAND = "/stats"
-    # /exit --delete: delete the session on the way out.
-    EXIT_DELETE_FLAG = "--delete"
-    # Leave, then archive the session (hidden from the lists, kept for good).
-    ARCHIVE_COMMAND = "/archive"
     SCRATCH_ARCHIVE_REFUSED = "a scratch session is deleted when you leave; nothing to archive"
-    RECAP_COMMAND = "/recap"
     # The prompt while a question waits for its answer (its choices are in
     # the notes slot).
     QUESTION_PROMPT = "? "
@@ -145,6 +137,9 @@ module Samagotchi
         # Re-resolve client after resume may change effective model
         @client = @host_registry.resolve(@effective_model_name).client
       end
+      # The model it starts on names a configured host (a bad default.model
+      # doesn't matter when --model or the session picks another).
+      ModelProfile.check_host!(@effective_model_name, hosts: @host_registry.entries)
       # Only a caller's profile goes in; otherwise the Engine resolves one
       # for the effective model and hands it to the kernel.
       @kernel         = KernelLoop.new(client: @client, profile: profile, no_interrupt: no_interrupt, reminder_store: Samagotchi::ReminderStore.new)
@@ -178,7 +173,9 @@ module Samagotchi
         profile: profile,
         session_id: session_id,
         no_interrupt: no_interrupt,
-        model_name: @default_model_name,
+        # nil: the config default, unchecked here (the model the REPL starts
+        # on is checked above, and --model may make the default moot).
+        model_name: nil,
         memories: @requested_memories,
         muted_memories: @muted_memory_names,
         kernel: @kernel,
@@ -426,26 +423,8 @@ module Samagotchi
       messages
     end
 
-    # Public entrypoint for background session workers.
-    # Keeps worker call sites out of TerminalUI private API details.
-    def process_background_prompt(session:, prompt:)
-      @engine.process_background_prompt(session: session, prompt: prompt)
-    end
-
     private
 
-    # Generate profile-aware tool calling hint.
-    # Kept as a one-line delegator to Engine (single source of truth).
-    def tool_call_hint
-      return @engine.tool_call_hint
-    end
-
-    # Assist system prompt — delegates wholesale to Engine so the two can
-    # never drift apart. This single delegator fixes the 4-line regression.
-    def assist_system_prompt
-      return @engine.assist_system_prompt
-    end
-
     # Interactive REPL loop. Session seed + messages are built by #run and
     # threaded in here (so --prompt / --resume share one code path). The
     # working session is persisted at the end of every turn.
@@ -559,21 +538,22 @@ module Samagotchi
           end
         end
         break if input.nil?
-        if exit_command?(input)
-          @delete_on_exit ||= delete_on_exit?(input)
+        local = local_command(input)
+        if local == :exit
+          @delete_on_exit ||= SessionCommands.delete_on_exit?(input)
           break
         end
-        if archive_command?(input)
+        if local == :archive
           next @surface.commit(SCRATCH_ARCHIVE_REFUSED) if @scratch
 
           @archive_on_exit = true
           break
         end
         # Not an answer to a continue offer either.
-        next detach_note if detach_command?(input)
+        next detach_note if local == :detach
 
         # /stats and /recap run; the offer stays open.
-        if @turn_flow.awaiting_continue? && !stats_command?(input) && !recap_command?(input)
+        if @turn_flow.awaiting_continue? && !%i[stats recap].include?(local)
           answer_continue_offer(session, input)
         else
           # The ? read left no echo: show what ran.
@@ -626,15 +606,14 @@ module Samagotchi
         persist_recent_history(input) if command.shell
         return
       end
-      return @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}") if stats_command?(input)
-      return @surface.commit("\nmodel> #{handle_recap_command}") if recap_command?(input)
+      return if show_local_command(input)
 
       @turn_flow.before_prompt_turn
       persist_recent_history(input)
       begin
         # Engine#run_turn injects due reminders as a tail message, appends
         # the prompt, and renders through @renderer via on_event.
-        result = run_engine_turn(session, normalize_model_input(input), images: ImageInput.extract(input))
+        result = run_engine_turn(session, input, images: ImageInput.extract(input))
       rescue LLM::ProviderError, ImageStore::Error => e
         # Engine closed the turn (:turn_failed); show its duration.
         # Retries were already tallied via generation_retrying events.
@@ -730,18 +709,6 @@ module Samagotchi
       prompt
     end
 
-    # Appends the current memory index to the base system prompt so the agent
-    # is always aware of stored memories without needing to call a tool first.
-    # Delegates wholesale to Engine (single source of truth).
-    def system_prompt_with_index(base)
-      result = @engine.system_prompt_with_index(base)
-      # Mirror any --memory activations the Engine performed so the sticky
-      # status line can surface them. The prompt body injection moved into
-      # Engine; echoing the activated names here is purely a UI concern.
-      sync_engine_activated_memories
-      result
-    end
-
     # Engine owns the system prompt (including --memory activation), but the
     # sticky status line is a UI concern. Mirror the activated names so they
     # appear in the status line.
@@ -751,12 +718,6 @@ module Samagotchi
       end
     end
 
-    # Render a result from a turn that bypassed Engine#run_turn (continue,
-    # reminder turns) exactly as a :turn_completed would be rendered.
-    def emit_result(result)
-      @renderer.render_turn_summary(@engine.turn_summary(result))
-    end
-
     # ── Turn view: the drawing surface EventRenderer calls ──────────────────
     public
 
@@ -827,8 +788,21 @@ module Samagotchi
         @thinking_waiting_since = nil
         clear_retry_spinner_status
         @turn_tally.started(key: tally_key(event), tool: event[:tool], params: event[:params])
-        memory_loaded = capture_memory_tool_call(event)
-        capture_thinking_tool_call(event) if memory_loaded
+        @last_tool_call_event = event
+        refresh_thinking_spinner_status
+      end
+    end
+
+    # The Engine's memory list: after a memory read (read_names, right after
+    # its tool_call_started) and at the end of a turn (preloads).
+    def used_memories_updated(event)
+      @spinner_lock.synchronize do
+        Array(event[:used_memory_names]).each { |name| add_unique_memory_name(:@session_memory_names, name) }
+        added = Array(event[:read_names]).select { |name| add_unique_memory_name(:@thinking_memory_names, name) }
+        next if added.empty?
+
+        @thinking_recent_memory_loaded = added.last
+        capture_thinking_tool_call(@last_tool_call_event) if @last_tool_call_event
         refresh_thinking_spinner_status
       end
     end
@@ -875,16 +849,6 @@ module Samagotchi
       @surface.commit("#{paint('chi>', 36)} turn #{state} (#{format_elapsed_duration(record[:duration_ms])})")
     end
 
-    def split_memory_scope(raw)
-      value = raw.to_s.strip
-      if value.include?("/")
-        scope, name = value.split("/", 2)
-        return [scope, name] if Tools::VALID_SCOPES.include?(scope)
-      end
-
-      [nil, value]
-    end
-
     def read_input(awaiting_continue:)
       emit_idle_status_line
 
@@ -910,6 +874,11 @@ module Samagotchi
       # empty synthetic turn then (it duplicated output).
       return unless @engine.reminders_due?
 
+      # A pending continue offer goes, as for a new prompt (the worker's rule).
+      if @turn_flow.before_reminder_turn
+        sync_continue_slot(false)
+        @surface.commit(QuestionSlot.continue_summary("(dropped: a reminder ran)", paint: method(:paint)))
+      end
       hint = "reminder: #{names.join(", ")} · Ctrl-C cancels it"
       @surface.set_slot(:hints, [color_output? ? paint(hint, 90) : hint])
       result = nil
@@ -1023,27 +992,20 @@ module Samagotchi
       @repl_input.prefill(input) ? "prompt restored for retry" : "the failed prompt is in the input history (↑)"
     end
 
-    def shell_bang_command?(input)
-      input.to_s.match?(/\A!\s*\S/)
-    end
-
-    def stats_command?(input)
-      input.to_s.strip == STATS_COMMAND
-    end
-
-    def recap_command?(input)
-      input.to_s.strip == RECAP_COMMAND
-    end
+    # The id of the terminal's own command +input+ is (:exit, :archive,
+    # :detach, :stats, :recap; SessionCommands registers them), or nil.
+    def local_command(input) = command_registry.lookup_local(input)&.id
 
-    # SessionCommands runs /model; the REPL mirrors the result.
-    def handle_model_command(input)
-      result = @commands.run(input)
-      sync_model_mirrors
-      result.output
-    end
-
-    def handle_models_command
-      @commands.run(SessionCommands::MODELS_COMMAND).output
+    # /stats and /recap, which show and change nothing (at the prompt, a
+    # continue offer's ? prompt, or during a turn).
+    # @return [Boolean] whether +input+ was one
+    def show_local_command(input)
+      case local_command(input)
+      when :stats then @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
+      when :recap then @surface.commit("\nmodel> #{handle_recap_command}")
+      else return false
+      end
+      true
     end
 
     # /recap: the saved recap, and a new one asked for at once when the
@@ -1060,31 +1022,10 @@ module Samagotchi
     # A resumed session doesn't get the default input either.
     def default_input_wanted? = !@resume_session && !@no_default_input
 
-    # exit or /exit, with --delete to delete the session on the way out.
-    def exit_command?(input)
-      words = input.to_s.strip.downcase.split
-      %w[exit /exit].include?(words.first) && (words.size == 1 || words == [words.first, EXIT_DELETE_FLAG])
-    end
-
-    def delete_on_exit?(input) = input.to_s.strip.downcase.split.last == EXIT_DELETE_FLAG
-
-    def detach_command?(input) = input.to_s.strip.casecmp?("/detach")
-
-    def archive_command?(input) = input.to_s.strip.casecmp?(ARCHIVE_COMMAND)
-
     def clone_messages(messages)
       Array(messages).map(&:dup)
     end
 
-    def skip_agent_description?
-      value = ENV[SKIP_AGENT_DESCRIPTION_ENV]
-      value == "1" || value&.casecmp?("true")
-    end
-
-    def rg_available?
-      system("command -v rg", out: File::NULL, err: File::NULL)
-    end
-
     # Run one REPL turn (a prompt, or a continue/reminder turn with nil) through
     # Engine#run_turn, rendering via @renderer.
     # @param images [Array<Hash>] the prompt's `@path` images ({path:})
@@ -1139,11 +1080,13 @@ module Samagotchi
     # in the prompt.
     # @return [Boolean, :back] whether the turn took it, :back to put it back
     def steer_line(line)
-      return exit_after_turn(delete: delete_on_exit?(line)) if line.nil? || exit_command?(line)
-      return detach_note if detach_command?(line)
+      local = local_command(line) unless line.nil?
+      return exit_after_turn(delete: SessionCommands.delete_on_exit?(line)) if line.nil? || local == :exit
+      return detach_note if local == :detach
       return false if @active_cancel_controller&.cancelled?
       return start_anytime_command(line) if command_registry.lookup(line)&.anytime
-      return command_during_turn(line) if command_line?(line)
+      # A command, never steering text (/archive waits, back in the prompt).
+      return command_during_turn(line) if local || command_registry.command?(line)
       return true if line.strip.empty?
       # Steering merges text only: a line with images runs as the next turn.
       return image_line_waits if ImageInput.extract(line).any?
@@ -1177,15 +1120,10 @@ module Samagotchi
 
     # @return [true, :back]
     def command_during_turn(line)
-      if stats_command?(line)
-        @surface.commit("\nmodel> session stats:\n#{format_session_metrics(@engine.stats_snapshot)}")
-      elsif recap_command?(line)
-        @surface.commit("\nmodel> #{handle_recap_command}")
-      else
-        @surface.commit(COMMAND_BUSY)
-        return :back
-      end
-      true
+      return true if show_local_command(line)
+
+      @surface.commit(COMMAND_BUSY)
+      :back
     end
 
     # D8: an anytime command runs on its own thread while the turn goes on
@@ -1205,16 +1143,12 @@ module Samagotchi
       true
     end
 
-    def command_line?(line)
-      command_registry.command?(line) || stats_command?(line) || recap_command?(line) || exit_command?(line)
-    end
-
-    # The kernel's drain at an iteration boundary: queued lines, #memory
-    # shorthand made words as for a prompt, and saved in the history.
+    # The kernel's drain at an iteration boundary: queued lines, sent as
+    # typed and saved in the history.
     def drain_steering
       @pending_input_queue.drain.map do |line|
         persist_recent_history(line)
-        normalize_model_input(line)
+        line
       end
     end
 
@@ -1372,17 +1306,6 @@ module Samagotchi
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def capture_memory_tool_call(event)
-      call = event[:call].is_a?(Hash) ? event[:call] : {}
-      memory_name = memory_name_from_tool_call(call)
-      return false if memory_name.nil? || memory_name.empty?
-
-      added_to_thinking = add_unique_memory_name(:@thinking_memory_names, memory_name)
-      add_unique_memory_name(:@session_memory_names, memory_name)
-      @thinking_recent_memory_loaded = memory_name if added_to_thinking
-      added_to_thinking
-    end
-
     def capture_thinking_tool_call(event)
       call = event[:call].is_a?(Hash) ? event[:call] : {}
       name = call[:name].to_s.strip
@@ -1440,67 +1363,6 @@ module Samagotchi
       true
     end
 
-    def memory_name_from_tool_call(call)
-      tool_name = call[:name].to_s
-      case tool_name
-      when Tools::MemoryRead::NAME
-        normalize_memory_name(call[:content])
-      when Tools::Read::NAME
-        memory_name_from_read_path(call[:content])
-      else
-        nil
-      end
-    end
-
-    def normalize_memory_name(raw)
-      value = raw.to_s.strip
-      return nil if value.empty?
-
-      File.basename(value, ".md")
-    end
-
-    def memory_name_from_read_path(raw_path)
-      path = raw_path.to_s.strip.tr("\\", "/")
-      return nil if path.empty?
-      return nil unless path.match?(/memories[\/].+\.md\z/)
-
-      normalize_memory_name(path)
-    end
-
-    def memory_spinner_segment
-      segment = memory_spinner_segment_plain
-      return "" if segment.empty?
-
-      color_output? ? paint(segment, MEMORY_SPINNER_COLOR) : segment
-    end
-
-    def memory_spinner_segment_plain
-      names = Array(@thinking_memory_names)
-      return "" if names.empty?
-
-      visible = names.first(MEMORY_SPINNER_PREVIEW_LIMIT)
-      suffix = names.length > visible.length ? ", +#{names.length - visible.length}" : ""
-      " mem: #{visible.join(', ')}#{suffix}"
-    end
-
-    def memory_sticky_line
-      names = Array(@session_memory_names)
-      muted = @engine.muted_memory_names
-      return "" if names.empty? && muted.empty?
-
-      parts = []
-      parts << "active this session: #{preview_names(names)}" unless names.empty?
-      parts << "muted: #{preview_names(muted)}" unless muted.empty?
-      body = "memories> #{parts.join(' · ')}"
-      color_output? ? paint(body, MEMORY_SPINNER_COLOR) : body
-    end
-
-    def preview_names(names, limit: MEMORY_STICKY_PREVIEW_LIMIT)
-      visible = names.first(limit)
-      suffix = names.length > visible.length ? ", +#{names.length - visible.length}" : ""
-      "#{visible.join(', ')}#{suffix}"
-    end
-
     def reset_thinking_memory_names
       @thinking_memory_names = []
     end
@@ -1622,54 +1484,24 @@ module Samagotchi
       ConfigFile.recap_config
     end
 
-    def bare_model_for(full_ref)
-      @host_registry.bare_name(full_ref)
-    end
-
-    def spinner_status_line
-      return "" unless status_line_enabled?
-
-      lines = spinner_status_lines
-      lines.empty? ? "" : lines.first
-    end
-
     def spinner_status_lines(width: status_effective_width)
       return [] unless status_line_enabled?
 
       build_status_lines(scope: :spinner, width: width)
     end
 
-    def sticky_status_line
-      return "" unless status_line_enabled?
-
-      lines = sticky_status_lines
-      lines.empty? ? "" : lines.first
-    end
-
     def sticky_status_lines(width: status_effective_width)
       return [] unless status_line_enabled?
 
       build_status_lines(scope: :sticky, width: width)
     end
 
-    def idle_status_line
-      return "" unless status_line_enabled?
-
-      lines = idle_status_lines
-      lines.empty? ? "" : lines.first
-    end
-
     def idle_status_lines(width: status_effective_width)
       return [] unless status_line_enabled?
 
       build_status_lines(scope: :idle, width: width)
     end
 
-    def build_status_line(scope:)
-      lines = build_status_lines(scope: scope)
-      lines.empty? ? "" : lines.first
-    end
-
     # The status rows for +scope+ (:spinner, :sticky or :idle), cut to +width+.
     def build_status_lines(scope:, width: status_effective_width)
       status_rows(status_segments(scope), width)
@@ -1845,11 +1677,6 @@ module Samagotchi
       "model> waiting for the first token... #{waited.floor}s #{frame}"
     end
 
-    def thinking_spinner_status_line(frame)
-      lines = thinking_spinner_status_lines(frame)
-      lines.empty? ? "" : lines.first
-    end
-
     # The spinner row, then (from a turn's 3rd tool call) its tool tally.
     # The spinner stops while tools run, so the tally shows while the model
     # generates between tool rounds.
@@ -1917,10 +1744,6 @@ module Samagotchi
       nil
     end
 
-    def pending_question_event?
-      !!@pending_question_event
-    end
-
     # Called from REPL thread (run_assist_loop top) — renders widget, blocks
     # until user selects, then answers via Engine#answer_question which wakes
     # the parked turn thread.
@@ -1962,6 +1785,9 @@ module Samagotchi
 
       # Ensure spinner cleared and terminal in known state (same as reminder mute handling)
       finish_thinking_spinner rescue nil
+      # An edit's diff goes above the slot, into the scrollback.
+      preview = prompt.preview_lines(paint: method(:paint))
+      @surface.commit(preview.join("\n")) unless preview.empty?
       choices = prompt.slot(paint: method(:paint))
 
       question_prompt = paint(QUESTION_PROMPT, 33)
@@ -2049,17 +1875,5 @@ module Samagotchi
         return :canceled if controller&.cancelled?
       end
     end
-
-    # Process a prompt through the kernel loop and return the model response.
-    # Delegates to the internal Engine instance.
-    def process_prompt_through_kernel(session, prompt)
-      @engine.process_prompt_through_kernel(session, prompt)
-    end
-
-    # Write an agent response to the session output directory.
-    def write_session_output(output_dir, response)
-      timestamp = Time.now.strftime("%Y%m%d%H%M%S%9N")
-      File.write(File.join(output_dir, "#{timestamp}.txt"), response.to_s)
-    end
   end
 end

data/lib/samagotchi/text_diff.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # Line-based unified diff (like `diff -u` without the file header), used to
+  # show what chi's edit/write tools change. Pure: strings in, a hash out.
+  #
+  #   TextDiff.unified("a\nb\n", "a\nc\n")
+  #   # => {text: "@@ -1,2 +1,2 @@\n a\n-b\n+c", added: 1, removed: 1, truncated: false}
+  #
+  # The common prefix and suffix are trimmed first (edits are local), then
+  # Myers O(ND) runs on the middle. When the edit distance passes
+  # MAX_EDIT_DISTANCE it gives up on a minimal diff and shows the whole middle
+  # as removed then added: correct, just not minimal. The text is cut at
+  # MAX_LINES / MAX_BYTES with a "… N more lines" line; the counts stay exact.
+  module TextDiff
+    CONTEXT = 3
+    MAX_LINES = 120
+    MAX_BYTES = 8 * 1024
+    MAX_EDIT_DISTANCE = 1000 # D² work: ~0.35 s for a dense 5 000-line edit
+    NO_NEWLINE = "\"
+
+    module_function
+
+    def unified(before, after, context: CONTEXT, max_lines: MAX_LINES, max_bytes: MAX_BYTES)
+      a = clean(before).lines
+      b = clean(after).lines
+      ops = edit_script(a, b)
+      added = ops.count { |op| op[0] == :add }
+      removed = ops.count { |op| op[0] == :del }
+      text, truncated = render(hunks(ops, context), a, b, max_lines, max_bytes)
+      { text: text, added: added, removed: removed, truncated: truncated }
+    end
+
+    def clean(text)
+      text.to_s.dup.force_encoding(Encoding::UTF_8).scrub("�")
+    end
+
+    # Ops are [:eq, ai, bi], [:del, ai, nil] or [:add, nil, bi] in file order.
+    def edit_script(a, b)
+      pre = 0
+      pre += 1 while pre < a.size && pre < b.size && a[pre] == b[pre]
+      suf = 0
+      suf += 1 while suf < a.size - pre && suf < b.size - pre && a[-1 - suf] == b[-1 - suf]
+
+      ops = (0...pre).map { |i| [:eq, i, i] }
+      a_mid = a[pre...(a.size - suf)]
+      b_mid = b[pre...(b.size - suf)]
+      middle = myers(a_mid, b_mid) ||
+               a_mid.each_index.map { |i| [:del, i, nil] } + b_mid.each_index.map { |j| [:add, nil, j] }
+      middle.each { |t, i, j| ops << [t, i && i + pre, j && j + pre] }
+      (0...suf).each { |s| ops << [:eq, a.size - suf + s, b.size - suf + s] }
+      ops
+    end
+
+    # Myers' greedy forward search, keeping one slice of V per round for the
+    # backtrack. Returns nil when the edit distance passes max_d.
+    def myers(a, b, max_d = MAX_EDIT_DISTANCE)
+      ids = {}
+      a = a.map { |l| ids[l] ||= ids.size }
+      b = b.map { |l| ids[l] ||= ids.size }
+      # No line in common (a full rewrite): the fallback is the minimal diff.
+      return nil if ids.size == a.uniq.size + b.uniq.size
+
+      n = a.size
+      m = b.size
+      off = n + m + 1
+      v = Array.new(2 * off + 1, 0)
+      trace = []
+      (0..(n + m)).each do |d|
+        return nil if d > max_d
+
+        # Round d reads k-1 and k+1 for k in -d..d: keep -(d+1)..d+1.
+        trace << v[off - d - 1, 2 * d + 3]
+        k = -d
+        while k <= d
+          x = if k == -d || (k != d && v[off + k - 1] < v[off + k + 1])
+                v[off + k + 1]
+              else
+                v[off + k - 1] + 1
+              end
+          y = x - k
+          while x < n && y < m && a[x] == b[y]
+            x += 1
+            y += 1
+          end
+          v[off + k] = x
+          return backtrack(trace, n, m) if x >= n && y >= m
+
+          k += 2
+        end
+      end
+      []
+    end
+
+    def backtrack(trace, x, y)
+      ops = []
+      (trace.size - 1).downto(0) do |d|
+        vd = trace[d]
+        at = ->(k) { vd[k + d + 1] }
+        k = x - y
+        prev_k = k == -d || (k != d && at.(k - 1) < at.(k + 1)) ? k + 1 : k - 1
+        prev_x = at.(prev_k)
+        prev_y = prev_x - prev_k
+        while x > prev_x && y > prev_y
+          x -= 1
+          y -= 1
+          ops << [:eq, x, y]
+        end
+        break if d.zero?
+
+        if x == prev_x
+          ops << [:add, nil, prev_y]
+        else
+          ops << [:del, prev_x, nil]
+        end
+        x = prev_x
+        y = prev_y
+      end
+      ops.reverse
+    end
+
+    # Groups ops into hunks: runs of changes whose gaps are at most 2*context
+    # unchanged lines, each padded with up to context lines on both sides.
+    def hunks(ops, context)
+      changed = ops.each_index.reject { |i| ops[i][0] == :eq }
+      return [] if changed.empty?
+
+      groups = [[changed.first, changed.first]]
+      changed.drop(1).each do |i|
+        if i - groups.last[1] - 1 <= 2 * context
+          groups.last[1] = i
+        else
+          groups << [i, i]
+        end
+      end
+      groups.map { |first, last| ops[[first - context, 0].max..[last + context, ops.size - 1].min] }
+    end
+
+    def render(hunks, a, b, max_lines, max_bytes)
+      lines = []
+      hunks.each do |hunk|
+        lines << header(hunk)
+        hunk.each do |t, i, j|
+          line = t == :add ? b[j] : a[i]
+          mark = { eq: " ", del: "-", add: "+" }[t]
+          # Only the "\n": chomp("\n") would take a CRLF's "\r" too.
+          lines << mark + (line.end_with?("\n") ? line[0...-1] : line)
+          lines << NO_NEWLINE unless line.end_with?("\n")
+        end
+      end
+      cut(lines, max_lines, max_bytes)
+    end
+
+    # @@ -start,len +start,len @@ with diff -u's conventions: ",1" is left
+    # out. A side with no lines in the hunk is an empty file (any other hunk
+    # has context lines), shown as 0,0.
+    def header(hunk)
+      a_lines = hunk.filter_map { |t, i, _| i unless t == :add }
+      b_lines = hunk.filter_map { |t, _, j| j unless t == :del }
+      "@@ -#{range(a_lines)} +#{range(b_lines)} @@"
+    end
+
+    def range(indexes)
+      return "0,0" if indexes.empty?
+
+      indexes.size == 1 ? (indexes.first + 1).to_s : "#{indexes.first + 1},#{indexes.size}"
+    end
+
+    def cut(lines, max_lines, max_bytes)
+      bytes = 0
+      lines.each_with_index do |line, i|
+        bytes += line.bytesize + 1
+        next unless i >= max_lines || bytes > max_bytes
+
+        rest = lines.size - i
+        return [(lines[0, i] + ["… #{rest} more lines"]).join("\n"), true]
+      end
+      [lines.join("\n"), false]
+    end
+  end
+end