ollama_chat 0.0.113 → 0.0.115

data/lib/ollama_chat/message_list.rb

@@ -70,6 +70,212 @@ class OllamaChat::MessageList
     @messages.size
   end
 
+  # Finds the message index at which compaction should cut.
+  #
+  # Walks non-system message groups (from +start+ onward) backward from
+  # the tail, accumulating per-group token estimates. Returns the index of
+  # the first message in the group whose addition causes the running total
+  # to meet or exceed +keep_recent_tokens+. Messages from +start+ up to
+  # that index are candidates for summarization; messages from that index
+  # onward are preserved.
+  #
+  # If every group together still fits under the budget, the index of the
+  # first group at or after +start+ is returned (signalling a no-op cut).
+  #
+  # @param start [Integer] the index at which to begin scanning (messages
+  #   before this index are excluded; typically the position just past an
+  #   existing summary message).
+  # @param keep_recent_tokens [Integer] the token budget for preserved
+  #   (recent) messages.
+  # @return [Integer, nil] the cut index into +@messages+, or +nil+ if
+  #   there are no non-system groups at or after +start+.
+  def find_cut_point(start:, keep_recent_tokens:)
+    groups = []
+    @messages.each_with_index do |msg, i|
+      next if msg.role == 'system'
+      next if i < start
+      tokens = msg.token_estimate(
+        strip_thinking: @chat.think_strip.on?
+      ).tokens
+      uuid = msg.group_uuid
+      if last = groups.last and last[:uuid] == uuid
+        last[:tokens] += tokens
+      else
+        groups << { uuid:, start: i, tokens: }
+      end
+    end
+    return nil if groups.empty?
+
+    accumulated = 0
+    groups.reverse_each do |group|
+      accumulated += group[:tokens]
+      return group[:start] if accumulated >= keep_recent_tokens
+    end
+    groups.first[:start]
+  end
+
+  # Finds the most recent summary message in the list.
+  #
+  # Scans backward from the tail for a message with
+  # `role == 'tool'` and `tool_name == 'summary'`.
+  #
+  # @return [OllamaChat::Message, nil] the summary message, or
+  #   `nil` if no summary has been inserted yet.
+  def find_summary
+    messages.reverse_each.find do |m|
+      m.role == 'tool' && m.tool_name == 'summary'
+    end
+  end
+
+  # Compacts the message list by summarizing old groups and inserting
+  # a single summary tool message at the cut point.
+  #
+  # Resolves the keep-recent token budget from the current model's context
+  # length, finds the cut point, summarizes all groups before it (passing
+  # any existing summary as +previous_summary+ for iterative re-compaction),
+  # then inserts the new summary at the cut point. Old groups remain in
+  # the list for retrieval via +lookup_group+; the LLM context builder
+  # skips them on the next call.
+  #
+  # @return [OllamaChat::Compaction::Result, nil] a +Result+ with
+  #   before/after context estimates on success, or +nil+ if there was
+  #   nothing to compact.
+  def compact!
+    ctx    = @chat.current_context_length
+    budget = @chat.compact_ratio_tokens(:keep_recent, ctx)
+
+    existing_summary = find_summary
+    start = @messages.each_with_index.find do |m, i|
+      m.role == 'tool' && m.tool_name == 'summary' and break i + 1
+    end
+    start ||= 0
+    start   = start.clamp(0..(@messages.size - 1))
+
+    # Cut among post-summary groups; the old summary is excluded
+    # from the budget window by +start+.
+    cut = find_cut_point(start:, keep_recent_tokens: budget)
+    return nil if cut.nil? || cut <= 1
+
+    candidates = @messages[start...cut]
+      .reject { |m| m.role == 'system' }
+      .reject { |m| m.role == 'tool' && m.tool_name == 'summary' }
+    return nil if candidates.empty?
+
+    cand_es = OllamaChat::TokenEstimator::Crude.new(
+      candidates.sum { |m| m.content.to_s.bytesize }
+    ).perform
+    context_before = @chat.context_usage
+
+    @chat.log(:info, 'Compaction: starting', data: {
+      context_length: ctx,
+      budget:         budget,
+      cut_index:      cut,
+      candidates:     candidates.size,
+      candidate_bytes: cand_es.bytes_formatted,
+      candidate_tokens: cand_es.tokens_formatted,
+      previous_summary: existing_summary ? 'yes' : 'no',
+    })
+
+    summary_text, all_tool_entries = @chat.summarize_for_compaction(
+      messages:         candidates,
+      previous_summary: existing_summary,
+    )
+
+    compact_es = OllamaChat::TokenEstimator.estimate(summary_text.bytesize)
+    @chat.log(:info, 'Compaction: summary generated', data: {
+      summary_bytes:   compact_es.bytes_formatted,
+      summary_tokens:  compact_es.tokens_formatted,
+    })
+
+    summary_msg = OllamaChat::Message.new(
+      role:       'tool',
+      tool_name:  'summary',
+      content:    summary_text,
+      tool_calls: all_tool_entries,
+    ).initialize_group_uuid
+
+    # Remove old summary (if any) and adjust cut for the shift.
+    if existing_summary
+      idx = @messages.index(existing_summary)
+      @messages.delete_at(idx)
+      cut -= 1 if idx < cut
+    end
+
+    @messages.insert(cut, summary_msg)
+    @chat.log(:info, 'Compaction: done', data: {
+      total_messages: @messages.size,
+      summary_at:     cut,
+    })
+    sync
+
+    OllamaChat::Compaction::Result.new(
+      context_before:,
+      context_after:  @chat.context_usage,
+      candidates:     candidates.size,
+      candidate_size: "#{cand_es.bytes_formatted} / " \
+                      "#{cand_es.tokens_formatted}",
+      summary_size:   "#{compact_es.bytes_formatted} / " \
+                      "#{compact_es.tokens_formatted}",
+      stored_total:   @chat.conversation_length,
+    )
+  end
+
+  # Returns the messages that will actually be sent to the LLM.
+  #
+  # If no summary message exists, returns all messages (identical to
+  # +to_ary+). If a summary is present, returns only the system prompt,
+  # the summary, and everything after it — groups before the summary
+  # are invisible to the model but remain in the list for
+  # +lookup_group+ retrieval.
+  #
+  # @return [Array<OllamaChat::Message>] the messages to send to the LLM
+  def compacted_messages
+    idx = @messages.rindex do |m|
+      m.role == 'tool' && m.tool_name == 'summary'
+    end
+    return to_ary if idx.nil?
+
+    system = @messages.take_while { |m| m.role == 'system' }
+    system + [@messages[idx]] + @messages[(idx + 1)..]
+  end
+
+  # Estimates the token and byte size of the messages that will actually
+  # be sent to the LLM (i.e. +compacted_messages+).
+  #
+  # When no summary message exists this is identical to the full list.
+  # When a summary is present, the pre-summary groups are excluded.
+  #
+  # Uses per-message +token_estimate+ which counts only text content
+  # (and thinking, unless +think_strip+ is enabled), excluding images
+  # and metadata scaffolding that would inflate a raw serialization.
+  #
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated token and
+  #   byte counts for the effective LLM payload.
+  def compacted_estimate_tokens
+    strip = @chat.think_strip.on?
+    bytes = compacted_messages.sum {
+      _1.token_estimate(strip_thinking: strip).bytes
+    }
+    OllamaChat::TokenEstimator.estimate(bytes)
+  end
+
+  # Estimates the token and byte size of the **full** stored message
+  # list (i.e. +@messages+), using per-message +token_estimate+.
+  #
+  # Unlike +Session#estimate_tokens+ which measures raw JSONL bytes
+  # (including base64 images and JSON scaffolding), this counts only
+  # text content and thinking (unless +think_strip+ is enabled).
+  #
+  # @return [OllamaChat::TokenEstimator::Estimate] the estimated token
+  #   and byte counts for the full conversation payload.
+  def full_estimate_tokens
+    strip = @chat.think_strip.on?
+    bytes = @messages.sum {
+      _1.token_estimate(strip_thinking: strip).bytes
+    }
+    OllamaChat::TokenEstimator.estimate(bytes)
+  end
+
   # The clear method removes all non-system messages from the message list.
   #
   # @return [ OllamaChat::MessageList ] self
@@ -148,6 +354,8 @@ class OllamaChat::MessageList
   def each_message(role: %w[ user assistant ], tool: false, &block)
     block or return enum_for(__method__, role:, tool:)
 
+    role = Array(role)
+
     @messages.each do |message|
       role.include?(message.role) or next
       !tool && message.tool? and next
@@ -305,14 +513,21 @@ class OllamaChat::MessageList
     self
   end
 
-  # Groups user/assistant messages by their group_uuid, allowing for easy
-  # manipulation of whole exchanges (User -> Runtime Info -> Assistant -> Tools).
-  #
-  # @yield [Array<OllamaChat::Message>] an array of messages belonging to the same group.
+  # Groups messages by their +group_uuid+, yielding an array of messages
+  # belonging to the same conversational turn (User -> Assistant -> Tools).
+  #
+  # @param role [Array<String>] the message roles to include when grouping.
+  #   Defaults to +%w[user assistant]+. Pass +%w[user assistant tool]+
+  #   to include tool-result messages as well.
+  # @param tool [Boolean] whether to include messages that carry a
+  #   +tool_name+ (tool calls / responses) among +user+ / +assistant+ roles.
+  #   Defaults to +false+.
+  # @yield [Array<OllamaChat::Message>] an array of messages sharing the
+  #   same +group_uuid+.
   # @return [Enumerator] if no block is given, returns an enumerator.
-  def each_group(&block)
-    block or return enum_for(__method__)
-    each_message.group_by(&:group_uuid).values.each(&block)
+  def each_group(role: %w[ user assistant ], tool: false, &block)
+    block or return enum_for(__method__, role:, tool:)
+    each_message(role:, tool:).group_by(&:group_uuid).values.each(&block)
   end
 
   # Removes the last `n` conversation exchanges from the message list.
@@ -411,8 +626,7 @@ class OllamaChat::MessageList
   # @return [self, NilClass] nil if the system prompt is empty, otherwise self.
   def show_system_prompt
     current_system = system.to_s
-    size_bytes     = current_system.size
-    es             = OllamaChat::TokenEstimator.estimate(size_bytes)
+    es             = OllamaChat::TokenEstimator.estimate(current_system)
     system_prompt  = @chat.kramdown_ansi_parse(current_system).
        gsub(/\n+\z/, '').full?
     if system_prompt.blank?

data/lib/ollama_chat/model_handling.rb

@@ -23,7 +23,7 @@ module OllamaChat::ModelHandling
   # @attr_reader system [String] the system prompt associated with the model
   # @attr_reader capabilities [Array<String>] the capabilities supported by the model
   # @attr_reader families [Array<String>] the families of the model
-  class ModelMetadata < Struct.new(:name, :system, :capabilities, :families)
+  class ModelMetadata < Data.define(:name, :system, :capabilities, :families)
     # Checks if the given capability is included in the object's capabilities.
     #
     # @param capability [String] the capability to check for

data/lib/ollama_chat/oc.rb

@@ -158,14 +158,24 @@ module OC
         default     XDG_STATE_HOME + 'history.jsonl'
       end
 
-      LOGFILE = set do
-        description 'File to output log messages to'
-        default     XDG_STATE_HOME + 'chat.log'
-      end
+      module LOG
+        description 'Logging configuration'
+
+        CHAT = set do
+          description 'Chat log file path'
+          default     XDG_STATE_HOME + 'chat.log'
+        end
 
-      DATABASE_LOGFILE = set do
-        description 'File to output database log messages to'
-        default     XDG_STATE_HOME + 'database.log'
+        DATABASE = set do
+          description 'Database log file path'
+          default     XDG_STATE_HOME + 'database.log'
+        end
+
+        TAIL_LINES = set do
+          description 'Max lines to keep in log files (truncate older)'
+          default     10_000
+          decode      { Integer(_1) }
+        end
       end
 
       USER = set do

data/lib/ollama_chat/ollama_chat_config/default_config.yml

@@ -74,6 +74,7 @@ prompts:
           markdown tables.
       - **Session**: %{session_name}
         - Context usage is %{context_usage}.
+        - Full conversation length is %{conversation_length}.
         - Markdown output is %{markdown}. **Never** output markdown as your
           responses if it is disabled.
         - Voice output is %{voice}. Speak naturally and short if voice
@@ -170,10 +171,10 @@ prompts:
 
       %{message_content}
     session_title: |
-      Create a title with a length of **less than %{length}** characters for this
-      conversation. Output only the title and nothing else:
-
       %{content}
+
+      Create a title with a length of **less than %{length}** characters for
+      the conversation above. Output only the title and nothing else.
     context_template_suggest: |
       Conversation History:
       %{history}
@@ -341,6 +342,39 @@ prompts:
       
       Output only the 9 suggestions as plain text, each separated by one empty line.
       No other text.
+  compaction:
+    system: |
+      You are a context summarizer for a chat application.
+      Your sole task is to produce a concise, factual narrative
+      summary of the conversation provided. Be precise, omit
+      speculation, and follow the formatting instructions in the
+      user prompt exactly. Output only the summary text.
+    summarize: |
+      previous_summary:
+      %{previous}
+
+      conversation:
+      %{groups}
+
+      Summarize the conversation above. Your narrative MUST:
+      - Name every file created or significantly modified (with
+        path), and the key methods or classes they define.
+      - State the architectural or design decisions made (e.g.
+        data-model choices, API shape, error-handling strategy).
+      - Describe the current state: what works, what is pending,
+        and any open questions or follow-ups.
+      - Do NOT merely report test counts or coverage percentages;
+        those are outcomes, not accomplishments.
+      - Be factual; do not invent details not present in the groups
+        above. Keep it to 6–12 sentences.
+    assemble: |-
+      %{narrative}
+
+      tool_calls:
+      %{tool_section}
+
+      To see the full output of any tool call above, use lookup_group
+      with the group UUID in parentheses.
   system:
     default: <%= OC::OLLAMA::CHAT::SYSTEM || "%{persona}\n\n%{runtime_info}".inspect %>
     persona: |
@@ -359,12 +393,22 @@ roles:
 markdown: true
 stream: true
 document_policy: importing
+parsing:
+  directory_structure_max_depth: 1
 think:
   mode: disabled
   loud: true
   strip: false
 context:
   format: JSON
+compaction:
+  enabled: true
+  reserve:
+    ratio: 0.60
+    min_tokens: 4096
+  keep_recent:
+    ratio: 0.20
+    min_tokens: 2048
 embedding:
   enabled: true
   paused: false
@@ -450,6 +494,10 @@ tools:
       result_display_timeout: 3
       cmd: |
         grep #{'-i' if ignore_case} -m #{max_results} -r #{before.full? { "-B %u " % it }}#{after.full? { "-A %u " % it }}#{context.full? { "-C %u " % it }}#{pattern} #{path}
+    execute_shell:
+      default: false
+      require_confirmation: false # Preflight confirm is skipped, but in-tool it's mandatory.
+      result_display_timeout: 0
     browse:
       result_display_timeout: 3
       default: true
@@ -492,6 +540,10 @@ tools:
     gem_path_lookup:
       result_display_timeout: 3
       default: true
+    lookup_group:
+      default: true
+      require_confirmation: false
+      result_display_timeout: 3
     open_file_in_editor:
       default: true
       require_confirmation: false
@@ -561,3 +613,20 @@ tools:
     eval_ruby:
       default: false
       result_display_timeout: 3
+syntax_checkers:
+  ruby:
+    cmd: [ 'ruby', '-wc' ]
+    suffixes: [ 'rb', 'rake', 'gemspec' ]
+    enabled: true
+  javascript:
+    cmd: [ 'node', '--check' ]
+    suffixes: [ 'js', 'mjs' ]
+    enabled: false
+  python:
+    cmd: [ 'python3', '-m', 'py_compile' ]
+    suffixes: [ 'py' ]
+    enabled: false
+  shell:
+    cmd: [ 'bash', '-n' ]
+    suffixes: [ 'sh', 'bash' ]
+    enabled: true

data/lib/ollama_chat/parsing.rb

@@ -279,7 +279,8 @@ module OllamaChat::Parsing
     contents = [ content ]
     content.scan(CONTENT_REGEXP).each { |url, file_url, quoted_file, file|
       if file && Pathname.new(file).expand_path.directory?
-        contents << generate_structure(file).to_json
+        max_depth = config.parsing.directory_structure_max_depth
+        contents << generate_structure(file, max_depth:).to_json
         next
       end
       check_exist = false

data/lib/ollama_chat/prompt_handling.rb

@@ -90,7 +90,7 @@ module OllamaChat::PromptHandling
 
     content = filename.read if filename&.exist?
     log(:info, "Prompt loaded from file", data: {
-      file: filename&.to_s, bytes: content&.size
+      file: filename&.to_s, bytes: content&.bytesize
     })
     content
   end

data/lib/ollama_chat/prompt_management.rb

@@ -449,6 +449,7 @@ module OllamaChat::PromptManagement
       end
     end
 
+    models::AppState.acknowledge(self)
     self
   end
 

data/lib/ollama_chat/rag_handling.rb

@@ -23,8 +23,6 @@ module OllamaChat::RAGHandling
     @documents.collection = old_collection
   end
 
-  private
-
   # Looks up a collection in the database by name.
   #
   # @param collection [String, Symbol, #to_s] the collection name to look up
@@ -34,6 +32,8 @@ module OllamaChat::RAGHandling
     models::Collection[name: collection.to_s]
   end
 
+  private
+
   # Returns the name of the currently active document collection.
   #
   # @return [String, Symbol] the name of the current collection
@@ -160,12 +160,13 @@ module OllamaChat::RAGHandling
   # highlighting the active one.
   def list_collections
     current_collection = collection.to_s
-    collections = all_collections.select(:name, :description)
+    collections = all_collections.select(:name, :description, :enabled)
     use_pager do |output|
       collections.each { |c|
         collection_name = current_collection == c.name ? bold { c.name } : c.name
         collection_description = c.description
-        output.puts '%s: %s' % [ collection_name, collection_description ]
+        suffix = c.enabled ? '' : ' [DISABLED]'
+        output.puts '%s: %s%s' % [ collection_name, collection_description, suffix ]
       }
     end
   end
@@ -306,13 +307,26 @@ module OllamaChat::RAGHandling
       extract_patterns(patterns_str)
     end
 
+    enabled_prompt = col.enabled ?
+      "🚫 Disable this collection? (hidden from the model) (y/n) " :
+      "✅ Enable this collection? (visible to the model) (y/n) "
+    toggle = case confirm?(prompt: enabled_prompt)
+             when /\Ay/i then true
+             when /\An/i then false
+             end
+
     col.description = new_description.full? ? new_description.to_s : col.description
     col.patterns    = patterns
+    col.enabled     = toggle ^ col.enabled unless toggle.nil?
 
     begin
       col.save
+      if toggle
+        status = col.enabled ? 'enabled' : 'disabled'
+        STDOUT.puts "🔄 Collection '#{col.name}' is now #{status}."
+      end
       STDOUT.puts "✅ Updated collection '#{col.name}'."
-      log(:info, "Collection updated", data: { name: col.name })
+      log(:info, "Collection updated", data: { name: col.name, enabled: col.enabled })
     rescue Sequel::Error => e
       STDERR.puts "❌ Database error: #{e.message}"
     end

data/lib/ollama_chat/session_management.rb

@@ -13,7 +13,7 @@ module OllamaChat::SessionManagement
     output = StringIO.new
     messages.write_conversation_jsonl(output)
     session.update(messages: output.string)
-    es = session.estimate_tokens
+    es = session.estimate_tokens # We just use the formatted bytecount
     log(:info, "Messages stored in session", data: {
       session_id:    session.id,
       size:          es.bytes_formatted,
@@ -135,9 +135,11 @@ module OllamaChat::SessionManagement
   #
   # @param output [IO] the output stream to write the information to (default: STDOUT)
   def show_session(output: STDOUT)
-    es             = session.estimate_tokens
+    es             = messages.full_estimate_tokens
     messages_count = session.count_messages
-    output.puts "#{bold{session.name}} (#{italic{session.id}}), #{es.bytes_formatted}/#{es.tokens_formatted}, #{messages_count} messages"
+    output.puts "#{bold{session.name}} (#{italic{session.id}}), "\
+      "#{es.tokens_formatted} (#{es.bytes_formatted}), "\
+      "#{messages_count} messages"
   end
 
   # Interactively prompts the user for a unique session name.

data/lib/ollama_chat/token_estimator/crude.rb

@@ -7,7 +7,7 @@ class OllamaChat::TokenEstimator::Crude
   # @raise [ArgumentError] if the input is not a string or an integer.
   def initialize(arg)
     if text = arg.ask_and_send(:to_str)
-      @bytes = text.size
+      @bytes = text.bytesize
     elsif bytes = arg.ask_and_send(:to_int)
       @bytes = bytes
     else

data/lib/ollama_chat/token_estimator.rb

@@ -10,7 +10,7 @@ require 'ollama_chat/token_estimator/crude'
 module OllamaChat::TokenEstimator
   # Represents the result of a calculation including raw values
   # and their human-readable formatted strings.
-  class Estimate < Struct.new(:bytes, :tokens)
+  class Estimate < Data.define(:bytes, :tokens)
     include OllamaChat::Utils::ValueFormatter
 
     # Returns the byte count in a formatted string (e.g., "1.2 KB").

data/lib/ollama_chat/tools/concern.rb

@@ -29,6 +29,23 @@ module OllamaChat::Tools::Concern
     #
     # @return [ String ] the register name of the tool
     attr_accessor :register_name
+
+    # Generates a one-line summary of a tool execution result for inclusion
+    # in compaction narratives.
+    #
+    # The default implementation extracts the `message` field from the
+    # result JSON (most tools already produce one). Falls back to a
+    # generic sentence if the field is absent or parsing fails.
+    #
+    # @param result [String] the raw JSON result string returned by `execute`
+    # @return [String] a short natural-language description of the call
+    def summary_template(result:)
+      default_message = "was called."
+      data            = JSON.parse(result)
+      data.is_a?(Hash) && data['message'] || default_message
+    rescue JSON::ParserError
+      default_message
+    end
   end
 
   # The name method returns the registered name of the tool.

data/lib/ollama_chat/tools/directory_structure.rb

@@ -28,10 +28,10 @@ class OllamaChat::Tools::DirectoryStructure
         description: <<~EOT,
           Tree viewer – Returns JSON describing files/folders under path up to
           max_depth (<= height of the tree), optionally only files ending with
-          suffix, e. g. rb for ruby files. Handy for locating resources or
-          presenting a project layout. Limit the required tokens by using the
-          max_depth parameter if possible, because the number of nodes in a
-          tree can grow exponentially with its height.
+          suffix / file extension, e. g. rb for ruby files. Handy for locating
+          resources or presenting a project layout. Limit the required tokens
+          by using the max_depth parameter if possible, because the number of
+          nodes in a tree can grow exponentially with its height.
         EOT
         parameters: Tool::Function::Parameters.new(
           type: 'object',
@@ -42,13 +42,17 @@ class OllamaChat::Tools::DirectoryStructure
             ),
             suffix: Tool::Function::Parameters::Property.new(
               type: 'string',
-              description: 'Only include files with this suffix, e. g. "rb" (defaults to all)'
+              description: <<~EOT
+                Only include files with this suffix / file extension, e. g.
+                "rb" (defaults to all)
+              EOT
             ),
             max_depth: Tool::Function::Parameters::Property.new(
               type: 'integer',
               description: <<~EOT,
-                Maximum depth of directory structure to return upto the total
-                height of the directory structure (defaults to disabled)
+                How many levels of the tree to include. 1 = immediate
+                children only, 2 = children + grandchildren, nil =
+                unlimited (defaults to nil)
               EOT
             ),
           },

data/lib/ollama_chat/tools/eval_ruby.rb

@@ -7,6 +7,7 @@ require 'open3'
 # It provides a safe way to test snippets and verify Ruby behavior.
 class OllamaChat::Tools::EvalRuby
   include OllamaChat::Tools::Concern
+  include Kramdown::ANSI::Width
 
   # @return [String] the registered name for this tool
   def self.register_name = 'eval_ruby'
@@ -79,18 +80,27 @@ class OllamaChat::Tools::EvalRuby
     result = stdout&.sub(/\ASwitch to inspect mode.\n/, '')
 
     if status.success?
+      result_truncated = truncate(result.to_s.strip, length: 80)
+      message          = "eval_ruby succeeded (#{version}): #{result_truncated.inspect}"
       {
         result:,
         version:,
-        status: 'success'
+        status: 'success',
+        message:  ,
       }.to_json
     else
+      message =
+        if stderr.empty?
+          "eval_ruby failed (#{version}): exit status #{status.exitstatus}"
+        else
+          "eval_ruby failed (#{version}): #{truncate(stderr.to_s.strip, length: 80).inspect}"
+        end
       {
-        error: 'ExecutionError',
-        message: stderr.empty? ? "Process exited with status #{status.exitstatus}" : stderr,
-        version:,
-        stdout:,
-        exit_status: status.exitstatus
+        error:       'ExecutionError',
+        message:     ,
+        version:     ,
+        stdout:      ,
+        exit_status: status.exitstatus,
       }.to_json
     end
   rescue => e