rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/tools/spawn_agent.rb

@@ -7,9 +7,10 @@ module RubynCode
   module Tools
     class SpawnAgent < Base
       TOOL_NAME = 'spawn_agent'
-      DESCRIPTION = 'Spawn an isolated sub-agent to handle a task. The sub-agent gets its own fresh context, ' \
-                    "works independently, and returns only a summary. Use 'explore' type for research/reading, " \
-                    "'worker' type for writing code/files. The sub-agent shares the filesystem but not your conversation."
+      DESCRIPTION = 'Spawn an isolated sub-agent to handle a task. The sub-agent gets its own ' \
+                    "fresh context, works independently, and returns only a summary. Use 'explore' " \
+                    "type for research/reading, 'worker' type for writing code/files. The sub-agent " \
+                    'shares the filesystem but not your conversation.'
       PARAMETERS = {
         prompt: {
           type: :string,
@@ -18,7 +19,7 @@ module RubynCode
         },
         agent_type: {
           type: :string,
-          description: "Type of agent: 'explore' (read-only tools) or 'worker' (full write access). Default: explore",
+          description: "Type of agent: 'explore' (read-only) or 'worker' (full write access). Default: explore",
           required: false,
           enum: %w[explore worker]
         }
@@ -36,113 +37,121 @@ module RubynCode
         callback.call(:started, "Spawning #{type} agent...")
 
         tools = tools_for_type(type)
-
-        result, hit_limit = run_sub_agent(prompt: prompt, tools: tools, type: type, callback: callback)
+        result, hit_limit = run_sub_agent(
+          prompt: prompt, tools: tools, type: type, callback: callback
+        )
 
         callback.call(:done, "Agent finished (#{@tool_count} tool calls).")
 
         summary = RubynCode::SubAgents::Summarizer.call(result, max_length: 3000)
+        format_agent_result(type, summary, hit_limit)
+      end
+
+      private
 
+      def format_agent_result(type, summary, hit_limit)
         if hit_limit
           "## Sub-Agent Result (#{type}) — INCOMPLETE (reached #{@tool_count} tool calls)\n\n" \
-            "The sub-agent ran out of turns before finishing. Here is what it accomplished so far:\n\n#{summary}"
+            'The sub-agent ran out of turns before finishing. Here is what it accomplished so far:' \
+            "\n\n#{summary}"
         else
           "## Sub-Agent Result (#{type})\n\n#{summary}"
         end
       end
 
-      private
+      def max_iterations_for(type)
+        if type == :explore
+          Config::Defaults::MAX_EXPLORE_AGENT_ITERATIONS
+        else
+          Config::Defaults::MAX_SUB_AGENT_ITERATIONS
+        end
+      end
 
       # Returns [result_text, hit_limit] tuple
       def run_sub_agent(prompt:, tools:, type:, callback:)
         conversation = RubynCode::Agent::Conversation.new
         conversation.add_user_message(prompt)
 
-        max_iterations = if type == :explore
-                           Config::Defaults::MAX_EXPLORE_AGENT_ITERATIONS
-                         else
-                           Config::Defaults::MAX_SUB_AGENT_ITERATIONS
-                         end
+        max_iterations = max_iterations_for(type)
         iteration = 0
         last_text = nil
 
         loop do
-          if iteration >= max_iterations
-            # Ask the LLM for a final summary of what it accomplished so far
-            conversation.add_user_message(
-              'You have reached your turn limit. Summarize everything you found or accomplished so far. ' \
-              'Be thorough — this is your last chance to report back.'
-            )
-            response = @llm_client.chat(
-              messages: conversation.to_api_format,
-              tools: [],
-              system: sub_agent_system_prompt(type)
-            )
-            content = response.respond_to?(:content) ? Array(response.content) : []
-            text_blocks = content.select { |b| b.respond_to?(:type) && b.type == 'text' }
-            summary = text_blocks.map(&:text).join("\n")
-
-            return [summary.empty? ? (last_text || '') : summary, true]
-          end
-
-          response = @llm_client.chat(
-            messages: conversation.to_api_format,
-            tools: tools,
-            system: sub_agent_system_prompt(type)
-          )
+          return finish_at_limit(conversation, type, last_text) if iteration >= max_iterations
 
-          content = response.respond_to?(:content) ? Array(response.content) : []
-          tool_calls = content.select { |b| b.respond_to?(:type) && b.type == 'tool_use' }
-
-          # Track the latest text output for partial results
-          text_blocks = content.select { |b| b.respond_to?(:type) && b.type == 'text' }
-          last_text = text_blocks.map(&:text).join("\n") unless text_blocks.empty?
+          last_text, done = process_iteration(
+            conversation, tools, type, callback, last_text
+          )
+          return [last_text || '', false] if done
 
-          if tool_calls.empty?
-            conversation.add_assistant_message(content)
-            return [last_text || '', false]
-          end
+          iteration += 1
+        end
+      end
 
-          # Add assistant message with tool calls
-          conversation.add_assistant_message(content)
+      def finish_at_limit(conversation, type, last_text)
+        conversation.add_user_message(
+          'You have reached your turn limit. Summarize everything you found or ' \
+          'accomplished so far. Be thorough — this is your last chance to report back.'
+        )
+        response = @llm_client.chat(
+          messages: conversation.to_api_format,
+          tools: [],
+          system: sub_agent_system_prompt(type)
+        )
+        summary = extract_text(response)
+        [summary.empty? ? (last_text || '') : summary, true]
+      end
 
-          # Execute each tool call
-          tool_calls.each do |tc|
-            name = tc.respond_to?(:name) ? tc.name : tc[:name]
-            input = tc.respond_to?(:input) ? tc.input : tc[:input]
-            id = tc.respond_to?(:id) ? tc.id : tc[:id]
+      def process_iteration(conversation, tools, type, callback, last_text)
+        response = @llm_client.chat(
+          messages: conversation.to_api_format,
+          tools: tools,
+          system: sub_agent_system_prompt(type)
+        )
 
-            @tool_count += 1
-            callback.call(:tool, name.to_s)
+        content = response_content(response)
+        tool_calls = content.select { |b| block_type?(b, 'tool_use') }
+        text_blocks = content.select { |b| block_type?(b, 'text') }
+        last_text = text_blocks.map(&:text).join("\n") unless text_blocks.empty?
 
-            begin
-              tool_class = RubynCode::Tools::Registry.get(name)
+        conversation.add_assistant_message(content)
+        return [last_text, true] if tool_calls.empty?
 
-              # Block recursive spawning
-              if %w[spawn_agent].include?(name)
-                conversation.add_tool_result(id, name, 'Error: Sub-agents cannot spawn other agents.', is_error: true)
-                next
-              end
+        execute_sub_agent_tools(tool_calls, conversation, type, callback)
+        [last_text, false]
+      end
 
-              # Block write tools for explore agents
-              if type == :explore && tool_class.risk_level != :read
-                conversation.add_tool_result(id, name, 'Error: Explore agents can only use read-only tools.',
-                                             is_error: true)
-                next
-              end
+      def execute_sub_agent_tools(tool_calls, conversation, type, callback)
+        tool_calls.each do |tc|
+          name, input, id = extract_tool_call(tc)
+          @tool_count += 1
+          callback.call(:tool, name.to_s)
 
-              tool = tool_class.new(project_root: project_root)
-              result = tool.execute(**input.transform_keys(&:to_sym))
-              truncated = tool.truncate(result.to_s)
+          run_single_tool(name, input, id, conversation, type)
+        end
+      end
 
-              conversation.add_tool_result(id, name, truncated)
-            rescue StandardError => e
-              conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
-            end
-          end
+      def run_single_tool(name, input, id, conversation, type)
+        if %w[spawn_agent].include?(name)
+          conversation.add_tool_result(
+            id, name, 'Error: Sub-agents cannot spawn other agents.', is_error: true
+          )
+          return
+        end
 
-          iteration += 1
+        tool_class = RubynCode::Tools::Registry.get(name)
+        if type == :explore && tool_class.risk_level != :read
+          conversation.add_tool_result(
+            id, name, 'Error: Explore agents can only use read-only tools.', is_error: true
+          )
+          return
         end
+
+        tool = tool_class.new(project_root: project_root)
+        result = tool.execute(**input.transform_keys(&:to_sym))
+        conversation.add_tool_result(id, name, tool.truncate(result.to_s))
+      rescue StandardError => e
+        conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
       end
 
       def tools_for_type(type)
@@ -150,28 +159,50 @@ module RubynCode
         blocked = %w[spawn_agent send_message read_inbox compact memory_write]
 
         if type == :explore
-          # Read-only tools
           read_tools = %w[read_file glob grep bash load_skill memory_search]
           all_tools.select { |t| read_tools.include?(t[:name]) }
         else
-          # Worker gets everything except agent-spawning and team tools
           all_tools.reject { |t| blocked.include?(t[:name]) }
         end
       end
 
       def sub_agent_system_prompt(type)
-        base = 'You are a Rubyn sub-agent. Complete your task efficiently and return a clear summary of what you found or did.'
+        base = 'You are a Rubyn sub-agent. Complete your task efficiently and ' \
+               'return a clear summary of what you found or did.'
 
         case type
         when :explore
-          "#{base}\nYou have read-only access. Search, read files, and analyze. Do NOT attempt to write or modify anything."
+          "#{base}\nYou have read-only access. Search, read files, and analyze. " \
+          'Do NOT attempt to write or modify anything.'
         when :worker
-          "#{base}\nYou have full read/write access. Make the changes needed, run tests if appropriate, and report what you did."
+          "#{base}\nYou have full read/write access. Make the changes needed, " \
+          'run tests if appropriate, and report what you did.'
         else
           base
         end
       end
 
+      def extract_text(response)
+        content = response_content(response)
+        text_blocks = content.select { |b| block_type?(b, 'text') }
+        text_blocks.map(&:text).join("\n")
+      end
+
+      def response_content(response)
+        response.respond_to?(:content) ? Array(response.content) : []
+      end
+
+      def block_type?(block, type)
+        block.respond_to?(:type) && block.type == type
+      end
+
+      def extract_tool_call(tool_call)
+        name = tool_call.respond_to?(:name) ? tool_call.name : tool_call[:name]
+        input = tool_call.respond_to?(:input) ? tool_call.input : tool_call[:input]
+        call_id = tool_call.respond_to?(:id) ? tool_call.id : tool_call[:id]
+        [name, input, call_id]
+      end
+
       def default_status(_type, message)
         RubynCode::Debug.agent("sub-agent: #{message}")
       end

data/lib/rubyn_code/tools/spawn_teammate.rb

@@ -43,7 +43,6 @@ module RubynCode
         teammate = manager.spawn(name: name, role: role)
         callback.call(:started, "Spawning teammate '#{name}' as #{role}...")
 
-        # Spawn a background thread running the teammate agent
         Thread.new do
           run_teammate_agent(teammate, prompt, mailbox, callback)
         end
@@ -57,48 +56,63 @@ module RubynCode
         conversation = Agent::Conversation.new
         conversation.add_user_message(initial_prompt)
 
-        system_prompt = "You are #{teammate.name}, a #{teammate.role} teammate agent. " \
-                        'Complete tasks efficiently. Use tools when needed. ' \
-                        'When done, provide a clear summary of what you accomplished.'
-
+        system_prompt = build_system_prompt(teammate)
         tools = tools_for_teammate
         max_iterations = Config::Defaults::MAX_SUB_AGENT_ITERATIONS
 
         max_iterations.times do
-          response = @llm_client.chat(
-            messages: conversation.to_api_format,
-            tools: tools,
-            system: system_prompt
+          done = process_teammate_iteration(
+            conversation, tools, system_prompt, teammate, mailbox, callback
           )
-
-          content = response.respond_to?(:content) ? Array(response.content) : []
-          tool_calls = content.select { |b| b.respond_to?(:type) && b.type == 'tool_use' }
-
-          if tool_calls.empty?
-            text = content.select { |b| b.respond_to?(:type) && b.type == 'text' }
-                          .map(&:text).join("\n")
-            conversation.add_assistant_message(content)
-            callback.call(:done, "Teammate '#{teammate.name}' finished initial task.")
-
-            # Send result back to main agent inbox
-            mailbox.send(from: teammate.name, to: 'rubyn', content: text)
-
-            # Now loop waiting for new messages
-            poll_inbox(teammate, conversation, tools, system_prompt, mailbox, callback)
-            return
-          end
-
-          conversation.add_assistant_message(content)
-          execute_tool_calls(tool_calls, conversation, callback)
+          return if done
         end
 
         callback.call(:done, "Teammate '#{teammate.name}' reached iteration limit.")
       rescue StandardError => e
         callback.call(:done, "Teammate '#{teammate.name}' error: #{e.message}")
-        RubynCode::Debug.agent("Teammate #{teammate.name} error: #{e.class}: #{e.message}")
+        RubynCode::Debug.agent(
+          "Teammate #{teammate.name} error: #{e.class}: #{e.message}"
+        )
       end
 
-      def poll_inbox(teammate, conversation, tools, system_prompt, mailbox, _callback)
+      def build_system_prompt(teammate)
+        "You are #{teammate.name}, a #{teammate.role} teammate agent. " \
+          'Complete tasks efficiently. Use tools when needed. ' \
+          'When done, provide a clear summary of what you accomplished.'
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def process_teammate_iteration(conversation, tools, system_prompt, teammate, mailbox, callback) # rubocop:disable Naming/PredicateMethod -- returns boolean but is an action method, not a predicate
+        response = @llm_client.chat(
+          messages: conversation.to_api_format,
+          tools: tools,
+          system: system_prompt
+        )
+
+        content = response_content(response)
+        tool_calls = content.select { |b| block_type?(b, 'tool_use') }
+
+        if tool_calls.empty?
+          finish_teammate_task(content, conversation, teammate, mailbox, callback)
+          poll_inbox(teammate, conversation, tools, system_prompt, mailbox)
+          return true
+        end
+
+        conversation.add_assistant_message(content)
+        execute_tool_calls(tool_calls, conversation, callback)
+        false
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def finish_teammate_task(content, conversation, teammate, mailbox, callback)
+        text = content.select { |b| block_type?(b, 'text') }
+                      .map(&:text).join("\n")
+        conversation.add_assistant_message(content)
+        callback.call(:done, "Teammate '#{teammate.name}' finished initial task.")
+        mailbox.send(from: teammate.name, to: 'rubyn', content: text)
+      end
+
+      def poll_inbox(teammate, conversation, tools, system_prompt, mailbox)
         loop do
           sleep Config::Defaults::POLL_INTERVAL
 
@@ -106,50 +120,64 @@ module RubynCode
           next if messages.empty?
 
           messages.each do |msg|
-            conversation.add_user_message(msg[:content])
-
-            response = @llm_client.chat(
-              messages: conversation.to_api_format,
-              tools: tools,
-              system: system_prompt
+            handle_inbox_message(
+              msg, conversation, tools, system_prompt, teammate, mailbox
             )
-
-            content = response.respond_to?(:content) ? Array(response.content) : []
-            conversation.add_assistant_message(content)
-
-            text = content.select { |b| b.respond_to?(:type) && b.type == 'text' }
-                          .map(&:text).join("\n")
-            mailbox.send(from: teammate.name, to: msg[:from], content: text) unless text.empty?
           end
         end
       rescue StandardError => e
-        RubynCode::Debug.agent("Teammate #{teammate.name} poll error: #{e.message}")
+        RubynCode::Debug.agent(
+          "Teammate #{teammate.name} poll error: #{e.message}"
+        )
       end
 
+      # rubocop:disable Metrics/ParameterLists
+      def handle_inbox_message(msg, conversation, tools, system_prompt, teammate, mailbox)
+        conversation.add_user_message(msg[:content])
+
+        response = @llm_client.chat(
+          messages: conversation.to_api_format,
+          tools: tools,
+          system: system_prompt
+        )
+
+        content = response_content(response)
+        conversation.add_assistant_message(content)
+
+        text = content.select { |b| block_type?(b, 'text') }
+                      .map(&:text).join("\n")
+        return if text.empty?
+
+        mailbox.send(from: teammate.name, to: msg[:from], content: text)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
       def execute_tool_calls(tool_calls, conversation, callback)
         tool_calls.each do |tc|
-          name = tc.respond_to?(:name) ? tc.name : tc[:name]
-          input = tc.respond_to?(:input) ? tc.input : tc[:input]
-          id = tc.respond_to?(:id) ? tc.id : tc[:id]
-
+          name, input, id = extract_tool_call(tc)
           callback.call(:tool, "  [teammate] > #{name}")
 
-          begin
-            # Block recursive spawning
-            if %w[spawn_agent spawn_teammate].include?(name)
-              conversation.add_tool_result(id, name, 'Error: Teammates cannot spawn other agents.', is_error: true)
-              next
-            end
-
-            tool_class = Registry.get(name)
-            tool = tool_class.new(project_root: project_root)
-            result = tool.execute(**input.transform_keys(&:to_sym))
-            truncated = tool.truncate(result.to_s)
-            conversation.add_tool_result(id, name, truncated)
-          rescue StandardError => e
-            conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
-          end
+          run_single_tool(name, input, id, conversation)
+        end
+      end
+
+      def run_single_tool(name, input, id, conversation)
+        if %w[spawn_agent spawn_teammate].include?(name)
+          conversation.add_tool_result(
+            id, name, 'Error: Teammates cannot spawn other agents.',
+            is_error: true
+          )
+          return
         end
+
+        tool_class = Registry.get(name)
+        tool = tool_class.new(project_root: project_root)
+        result = tool.execute(**input.transform_keys(&:to_sym))
+        conversation.add_tool_result(id, name, tool.truncate(result.to_s))
+      rescue StandardError => e
+        conversation.add_tool_result(
+          id, name, "Error: #{e.message}", is_error: true
+        )
       end
 
       def tools_for_teammate
@@ -158,6 +186,21 @@ module RubynCode
         all_tools.reject { |t| blocked.include?(t[:name]) }
       end
 
+      def response_content(response)
+        response.respond_to?(:content) ? Array(response.content) : []
+      end
+
+      def block_type?(block, type)
+        block.respond_to?(:type) && block.type == type
+      end
+
+      def extract_tool_call(tool_call)
+        name = tool_call.respond_to?(:name) ? tool_call.name : tool_call[:name]
+        input = tool_call.respond_to?(:input) ? tool_call.input : tool_call[:input]
+        call_id = tool_call.respond_to?(:id) ? tool_call.id : tool_call[:id]
+        [name, input, call_id]
+      end
+
       def default_status(_type, message)
         RubynCode::Debug.agent("spawn_teammate: #{message}")
       end

data/lib/rubyn_code/tools/spec_output_parser.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Parses raw test framework output (RSpec/Minitest) into compact summaries.
+    # Passing suites compress to a single line; failures preserve enough context
+    # to diagnose the issue without the full verbose output.
+    module SpecOutputParser
+      MAX_FAILURE_LINES = 15
+      MAX_FAILURES = 10
+
+      class << self
+        # Parse raw spec output into a compact summary.
+        #
+        # @param raw [String] raw test framework output
+        # @return [String] compressed summary
+        def parse(raw)
+          return '(no output)' if raw.nil? || raw.strip.empty?
+
+          if rspec_output?(raw)
+            parse_rspec(raw)
+          elsif minitest_output?(raw)
+            parse_minitest(raw)
+          else
+            raw
+          end
+        end
+
+        private
+
+        def rspec_output?(raw)
+          raw.include?('example') && (raw.include?('failure') || raw.include?('pending'))
+        end
+
+        def minitest_output?(raw)
+          raw.include?('assertions') || raw.include?('runs,')
+        end
+
+        def parse_rspec(raw)
+          summary = extract_rspec_summary(raw)
+          return summary if summary && !raw.include?('FAILED') && raw.match?(/0 failures/)
+
+          failures = extract_rspec_failures(raw)
+          parts = []
+          parts.concat(format_failures(failures))
+          parts << summary if summary
+          parts.empty? ? raw : parts.join("\n")
+        end
+
+        def extract_rspec_summary(raw)
+          raw.lines.reverse_each do |line|
+            return line.strip if line.match?(/\d+ examples?.*\d+ failures?/)
+          end
+          nil
+        end
+
+        def extract_rspec_failures(raw)
+          failures = []
+          current = nil
+
+          raw.each_line do |line|
+            if line.match?(/^\s+\d+\)\s/)
+              failures << current if current
+              current = { header: line.strip, body: [] }
+            elsif current
+              current[:body] << line.rstrip if current[:body].size < MAX_FAILURE_LINES
+            end
+          end
+
+          failures << current if current
+          failures.first(MAX_FAILURES)
+        end
+
+        def parse_minitest(raw)
+          summary = extract_minitest_summary(raw)
+          return summary if summary && raw.match?(/0 failures/)
+
+          failures = extract_minitest_failures(raw)
+          parts = []
+          parts.concat(format_failures(failures))
+          parts << summary if summary
+          parts.empty? ? raw : parts.join("\n")
+        end
+
+        def extract_minitest_summary(raw)
+          raw.lines.reverse_each do |line|
+            return line.strip if line.match?(/\d+ runs?,\s*\d+ assertions?/)
+          end
+          nil
+        end
+
+        def extract_minitest_failures(raw)
+          failures = []
+          current = nil
+
+          raw.each_line do |line|
+            if line.match?(/^\s+\d+\)\s(Failure|Error):/)
+              failures << current if current
+              current = { header: line.strip, body: [] }
+            elsif current
+              current[:body] << line.rstrip if current[:body].size < MAX_FAILURE_LINES
+            end
+          end
+
+          failures << current if current
+          failures.first(MAX_FAILURES)
+        end
+
+        def format_failures(failures)
+          failures.map do |f|
+            body = f[:body].reject(&:empty?).first(MAX_FAILURE_LINES)
+            "#{f[:header]}\n#{body.join("\n")}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/task.rb

@@ -7,7 +7,8 @@ module RubynCode
   module Tools
     class Task < Base
       TOOL_NAME = 'task'
-      DESCRIPTION = 'Manage tasks: create, update, complete, list, or get tasks for tracking work items and dependencies.'
+      DESCRIPTION = 'Manage tasks: create, update, complete, list, or get tasks ' \
+                    'for tracking work items and dependencies.'
       PARAMETERS = {
         action: {
           type: :string, required: true,
@@ -63,21 +64,25 @@ module RubynCode
         when 'list'    then execute_list(manager, **params)
         when 'get'     then execute_get(manager, **params)
         else
-          raise Error, "Unknown task action: #{action}. Valid actions: create, update, complete, list, get"
+          raise Error,
+                "Unknown task action: #{action}. Valid: create, update, complete, list, get"
         end
       end
 
+      TASK_OPTIONAL_FIELDS = %i[owner result session_id description].freeze
+
       private
 
-      def execute_create(manager, title: nil, description: nil, session_id: nil, blocked_by: [], priority: 0, **)
+      def execute_create(manager, **params)
+        title = params[:title]
         raise Error, 'title is required for create' if title.nil? || title.empty?
 
         task = manager.create(
           title: title,
-          description: description,
-          session_id: session_id,
-          blocked_by: Array(blocked_by),
-          priority: priority.to_i
+          description: params[:description],
+          session_id: params[:session_id],
+          blocked_by: Array(params.fetch(:blocked_by, [])),
+          priority: params.fetch(:priority, 0).to_i
         )
 
         format_task(task, prefix: 'Created task')
@@ -124,16 +129,11 @@ module RubynCode
 
       def format_task(task, prefix: nil)
         header = prefix ? "#{prefix}: #{task.title}" : task.title
-        parts = [
-          header,
-          "  ID:       #{task.id}",
-          "  Status:   #{task.status}",
-          "  Priority: #{task.priority}"
-        ]
-        parts << "  Owner:    #{task.owner}" if task.owner
-        parts << "  Result:   #{task.result}" if task.result
-        parts << "  Session:  #{task.session_id}" if task.session_id
-        parts << "  Description: #{task.description}" if task.description
+        parts = [header, "  ID:       #{task.id}", "  Status:   #{task.status}", "  Priority: #{task.priority}"]
+        TASK_OPTIONAL_FIELDS.each do |field|
+          value = task.public_send(field)
+          parts << "  #{field.to_s.capitalize.tr('_', ' ')}: #{value}" if value
+        end
         parts.join("\n")
       end