roast-ai 0.3.1 → 0.4.1

data/lib/roast/tools/cmd.rb

@@ -2,6 +2,7 @@
 
 require "English"
 require "roast/helpers/logger"
+require "roast/helpers/timeout_handler"
 
 module Roast
   module Tools
@@ -65,6 +66,11 @@ module Roast
                 description: "Arguments to pass to the #{command} command",
                 required: false,
               },
+              timeout: {
+                type: "integer",
+                description: "Timeout in seconds (optional, default: 30)",
+                required: false,
+              },
             ) do |params|
               full_command = if params[:args].nil? || params[:args].empty?
                 command
@@ -72,7 +78,7 @@ module Roast
                 "#{command} #{params[:args]}"
               end
 
-              Roast::Tools::Cmd.execute_allowed_command(full_command, command)
+              Roast::Tools::Cmd.execute_allowed_command(full_command, command, params[:timeout])
             end
           end
         end
@@ -83,15 +89,16 @@ module Roast
         end
       end
 
-      def execute_allowed_command(full_command, command_prefix)
+      def execute_allowed_command(full_command, command_prefix, timeout = 30)
         Roast::Helpers::Logger.info("🔧 Running command: #{full_command}\n")
-        execute_command(full_command, command_prefix)
+
+        execute_command(full_command, command_prefix, timeout)
       rescue StandardError => e
         handle_error(e)
       end
 
       # Legacy method for backward compatibility
-      def call(command, config = {})
+      def call(command, config = {}, timeout: 30)
         Roast::Helpers::Logger.info("🔧 Running command: #{command}\n")
 
         allowed_commands = config[CONFIG_ALLOWED_COMMANDS] || DEFAULT_ALLOWED_COMMANDS
@@ -99,7 +106,8 @@ module Roast
         return validation_result unless validation_result.nil?
 
         command_prefix = command.split(" ").first
-        execute_command(command, command_prefix)
+
+        execute_command(command, command_prefix, timeout)
       rescue StandardError => e
         handle_error(e)
       end
@@ -130,16 +138,25 @@ module Roast
         configuration&.tool_config("Roast::Tools::Cmd") || {}
       end
 
-      def execute_command(command, command_prefix)
-        result = if command_prefix == "dev"
-          # Use bash -l -c to ensure we get a login shell with all environment variables
-          full_command = "bash -l -c '#{command.gsub("'", "\\'")}'"
-          IO.popen(full_command, chdir: Dir.pwd, &:read)
+      def execute_command(command, command_prefix, timeout)
+        timeout = Roast::Helpers::TimeoutHandler.validate_timeout(timeout)
+
+        full_command = if command_prefix == "dev"
+          "bash -l -c '#{command.gsub("'", "\\'")}'"
         else
-          IO.popen(command, chdir: Dir.pwd, &:read)
+          command
         end
 
-        format_output(command, result, $CHILD_STATUS.exitstatus)
+        result, exit_status = Roast::Helpers::TimeoutHandler.call(
+          full_command,
+          timeout: timeout,
+          working_directory: Dir.pwd,
+        )
+
+        format_output(command, result, exit_status)
+      rescue Timeout::Error => e
+        Roast::Helpers::Logger.error(e.message + "\n")
+        e.message
       end
 
       def format_output(command, result, exit_status)

data/lib/roast/tools/coding_agent.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-require "roast/tools/helpers/coding_agent_message_formatter"
-require "json"
-require "open3"
-require "tempfile"
-require "securerandom"
-
 module Roast
   module Tools
     module CodingAgent
@@ -26,10 +19,16 @@ module Roast
           base.class_eval do
             function(
               :coding_agent,
-              "AI-powered coding agent that runs Claude Code CLI with the given prompt",
+              "AI-powered coding agent that runs an instance of the Claude Code agent with the given prompt. If the agent is iterating on previous work, set continue to true.",
               prompt: { type: "string", description: "The prompt to send to Claude Code" },
+              include_context_summary: { type: "boolean", description: "Whether to set a summary of the current workflow context as system directive (default: false)", required: false },
+              continue: { type: "boolean", description: "Whether to continue where the previous coding agent left off or start with a fresh context (default: false, start fresh)", required: false },
             ) do |params|
-              Roast::Tools::CodingAgent.call(params[:prompt])
+              Roast::Tools::CodingAgent.call(
+                params[:prompt],
+                include_context_summary: params[:include_context_summary].presence || false,
+                continue: params[:continue].presence || false,
+              )
             end
           end
         end
@@ -40,9 +39,9 @@ module Roast
         end
       end
 
-      def call(prompt)
+      def call(prompt, include_context_summary: false, continue: false)
         Roast::Helpers::Logger.info("🤖 Running CodingAgent\n")
-        run_claude_code(prompt)
+        run_claude_code(prompt, include_context_summary:, continue:)
       rescue StandardError => e
         "Error running CodingAgent: #{e.message}".tap do |error_message|
           Roast::Helpers::Logger.error(error_message + "\n")
@@ -52,7 +51,7 @@ module Roast
 
       private
 
-      def run_claude_code(prompt)
+      def run_claude_code(prompt, include_context_summary:, continue:)
         Roast::Helpers::Logger.debug("🤖 Executing Claude Code CLI with prompt: #{prompt}\n")
 
         # Create a temporary file with a unique name
@@ -62,14 +61,21 @@ module Roast
         temp_file = Tempfile.new(["claude_prompt_#{timestamp}_#{pid}_#{random_id}", ".txt"])
 
         begin
+          # Prepare the final prompt with context summary if requested
+          final_prompt = prepare_prompt(prompt, include_context_summary)
+
           # Write the prompt to the file
-          temp_file.write(prompt)
+          temp_file.write(final_prompt)
           temp_file.close
 
+          # Build the command with continue option if specified
+          base_command = claude_code_command
+          command_to_run = build_command(base_command, continue:)
+
           # Run Claude Code CLI using the temp file as input with streaming output
-          expect_json_output = claude_code_command.include?("--output-format stream-json") ||
-            claude_code_command.include?("--output-format json")
-          command = "cat #{temp_file.path} | #{claude_code_command}"
+          expect_json_output = command_to_run.include?("--output-format stream-json") ||
+            command_to_run.include?("--output-format json")
+          command = "cat #{temp_file.path} | #{command_to_run}"
           result = ""
 
           Open3.popen3(command) do |stdin, stdout, stderr, wait_thread|
@@ -110,7 +116,7 @@ module Roast
       def handle_intermediate_message(json)
         case json["type"]
         when "assistant", "user"
-          CodingAgentMessageFormatter.format_messages(json).each(&method(:log_message))
+          Roast::Tools::Helpers::CodingAgentMessageFormatter.format_messages(json).each(&method(:log_message))
         when "result", "system"
           # Ignore these message types
         else
@@ -143,6 +149,48 @@ module Roast
       def claude_code_command
         CodingAgent.configured_command || ENV["CLAUDE_CODE_COMMAND"] || "claude -p --verbose --output-format stream-json"
       end
+
+      def build_command(base_command, continue:)
+        return base_command unless continue
+
+        # Add --continue flag to the command
+        # If the command already has flags, insert --continue after 'claude'
+        if base_command.start_with?("claude ")
+          base_command.sub("claude ", "claude --continue ")
+        else
+          # Fallback for non-standard commands
+          "#{base_command} --continue"
+        end
+      end
+
+      def prepare_prompt(prompt, include_context_summary)
+        return prompt unless include_context_summary
+
+        context_summary = generate_context_summary(prompt)
+        return prompt if context_summary.blank? || context_summary == "No relevant information found in the workflow context."
+
+        # Prepend context summary as a system directive
+        <<~PROMPT
+          <system>
+          #{context_summary}
+          </system>
+
+          #{prompt}
+        PROMPT
+      end
+
+      def generate_context_summary(agent_prompt)
+        # Access the current workflow context if available
+        workflow_context = Thread.current[:workflow_context]
+        return unless workflow_context
+
+        # Use ContextSummarizer to generate an intelligent summary
+        summarizer = ContextSummarizer.new
+        summarizer.generate_summary(workflow_context, agent_prompt)
+      rescue => e
+        Roast::Helpers::Logger.debug("Failed to generate context summary: #{e.message}\n")
+        nil
+      end
     end
   end
 end

data/lib/roast/tools/context_summarizer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Roast
+  module Tools
+    class ContextSummarizer
+      include Raix::ChatCompletion
+
+      attr_reader :model
+
+      def initialize(model: "o4-mini")
+        @model = model
+      end
+
+      # Generate an intelligent summary of the workflow context
+      # tailored to what the agent needs to know for its upcoming task
+      #
+      # @param workflow_context [Object] The workflow context from Thread.current
+      # @param agent_prompt [String] The prompt the agent is about to execute
+      # @return [String, nil] The generated summary or nil if generation fails
+      def generate_summary(workflow_context, agent_prompt)
+        return unless workflow_context&.workflow
+
+        context_data = build_context_data(workflow_context.workflow)
+        summary_prompt = build_summary_prompt(context_data, agent_prompt)
+
+        # Use our own transcript for the summary generation
+        self.transcript = []
+        prompt(summary_prompt)
+
+        result = chat_completion
+        result&.strip
+      rescue => e
+        Roast::Helpers::Logger.debug("Failed to generate LLM context summary: #{e.message}\n")
+        nil
+      end
+
+      private
+
+      def build_context_data(workflow)
+        data = {}
+
+        # Add workflow description if available
+        if workflow.config && workflow.config["description"]
+          data[:workflow_description] = workflow.config["description"]
+        end
+
+        # Add step outputs if available
+        if workflow.output && !workflow.output.empty?
+          data[:step_outputs] = workflow.output.map do |step_name, output|
+            # Include full output for context generation
+            { step: step_name, output: output }
+          end
+        end
+
+        # Add current working directory
+        data[:working_directory] = Dir.pwd
+
+        # Add workflow name if available
+        if workflow.respond_to?(:name)
+          data[:workflow_name] = workflow.name
+        end
+
+        data
+      end
+
+      def build_summary_prompt(context_data, agent_prompt)
+        prompt_parts = []
+
+        prompt_parts << "You are preparing a context summary for an AI coding agent (Claude Code) that is about to perform a task."
+        prompt_parts << "\nThe agent's upcoming task is:"
+        prompt_parts << "```"
+        prompt_parts << agent_prompt
+        prompt_parts << "```"
+
+        prompt_parts << "\nBased on the following workflow context, provide a concise summary of ONLY the information that would be relevant for the agent to complete this specific task."
+
+        if context_data[:workflow_description]
+          prompt_parts << "\nWorkflow Description: #{context_data[:workflow_description]}"
+        end
+
+        if context_data[:workflow_name]
+          prompt_parts << "\nWorkflow Name: #{context_data[:workflow_name]}"
+        end
+
+        if context_data[:working_directory]
+          prompt_parts << "\nWorking Directory: #{context_data[:working_directory]}"
+        end
+
+        if context_data[:step_outputs] && !context_data[:step_outputs].empty?
+          prompt_parts << "\nPrevious Step Outputs:"
+          context_data[:step_outputs].each do |step_data|
+            prompt_parts << "\n### Step: #{step_data[:step]}"
+            prompt_parts << "Output: #{step_data[:output]}"
+          end
+        end
+
+        prompt_parts << "\n\nGenerate a brief context summary that:"
+        prompt_parts << "1. Focuses ONLY on information relevant to the agent's upcoming task"
+        prompt_parts << "2. Highlights key findings, decisions, or outputs the agent should be aware of"
+        prompt_parts << "3. Is concise and actionable (aim for 3-5 sentences)"
+        prompt_parts << "4. Does not repeat information that would be obvious from the agent's prompt"
+        prompt_parts << "\nIf there is no relevant context for this task, respond with 'No relevant information found in the workflow context.'"
+
+        prompt_parts.join("\n")
+      end
+    end
+  end
+end

data/lib/roast/tools/grep.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-
 module Roast
   module Tools
     module Grep
@@ -30,7 +28,6 @@ module Roast
         Roast::Helpers::Logger.info("🔍 Grepping for string: #{string}\n")
 
         # Use Open3 to safely pass the string as an argument, avoiding shell injection
-        require "open3"
         cmd = ["rg", "-C", "4", "--trim", "--color=never", "--heading", "-F", "--", string, "."]
         stdout, _stderr, _status = Open3.capture3(*cmd)
 

data/lib/roast/tools/helpers/coding_agent_message_formatter.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
-require "yaml"
-
 module Roast
   module Tools
-    module CodingAgent
+    module Helpers
       module CodingAgentMessageFormatter
         extend self
 

data/lib/roast/tools/read_file.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-
 module Roast
   module Tools
     module ReadFile

data/lib/roast/tools/search_file.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/helpers/logger"
-
 module Roast
   module Tools
     module SearchFile

data/lib/roast/tools/swarm.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Roast
+  module Tools
+    module Swarm
+      extend self
+
+      DEFAULT_CONFIG_PATHS = [
+        ".swarm.yml",
+        "swarm.yml",
+        ".swarm/config.yml",
+      ].freeze
+
+      CONFIG_PATH_KEY = "path"
+      private_constant :DEFAULT_CONFIG_PATHS, :CONFIG_PATH_KEY
+
+      class << self
+        def included(base)
+          base.class_eval do
+            function(
+              :swarm,
+              "Execute Claude Swarm to orchestrate multiple Claude Code instances",
+              prompt: {
+                type: "string",
+                description: "The prompt to send to the swarm agents",
+                required: true,
+              },
+              path: {
+                type: "string",
+                description: "Path to the swarm configuration file (optional)",
+                required: false,
+              },
+            ) do |params|
+              Roast::Tools::Swarm.call(params[:prompt], params[:path])
+            end
+          end
+        end
+
+        def post_configuration_setup(base, config = {})
+          @tool_config = config
+        end
+
+        attr_reader :tool_config
+      end
+
+      def call(prompt, step_path = nil)
+        config_path = determine_config_path(step_path)
+
+        if config_path.nil?
+          return "Error: No swarm configuration file found. Please create a .swarm.yml file or specify a path."
+        end
+
+        unless File.exist?(config_path)
+          return "Error: Swarm configuration file not found at: #{config_path}"
+        end
+
+        Roast::Helpers::Logger.info("🐝 Running Claude Swarm with config: #{config_path}\n")
+
+        execute_swarm(prompt, config_path)
+      rescue StandardError => e
+        handle_error(e)
+      end
+
+      private
+
+      def determine_config_path(step_path)
+        # Priority: step-level path > tool-level path > default locations
+
+        # 1. Check step-level path
+        return step_path if step_path
+
+        # 2. Check tool-level path from configuration
+        if tool_config && tool_config[CONFIG_PATH_KEY]
+          return tool_config[CONFIG_PATH_KEY]
+        end
+
+        # 3. Check default locations
+        DEFAULT_CONFIG_PATHS.find { |path| File.exist?(path) }
+      end
+
+      def execute_swarm(prompt, config_path)
+        # Build the swarm command with proper escaping
+        command = build_swarm_command(prompt, config_path)
+
+        result = ""
+
+        # Execute the command directly with the prompt included
+        IO.popen(command, err: [:child, :out]) do |io|
+          result = io.read
+        end
+
+        exit_status = $CHILD_STATUS.exitstatus
+
+        format_output(command, result, exit_status)
+      end
+
+      def build_swarm_command(prompt, config_path)
+        # Build the claude-swarm command with properly escaped arguments
+        [
+          "claude-swarm",
+          "--config",
+          config_path,
+          "--prompt",
+          prompt,
+        ].shelljoin
+      end
+
+      def format_output(command, result, exit_status)
+        "Command: #{command}\n" \
+          "Exit status: #{exit_status}\n" \
+          "Output:\n#{result}"
+      end
+
+      def handle_error(error)
+        error_message = "Error running swarm: #{error.message}"
+        Roast::Helpers::Logger.error("#{error_message}\n")
+        Roast::Helpers::Logger.debug("#{error.backtrace.join("\n")}\n") if ENV["DEBUG"]
+        error_message
+      end
+    end
+  end
+end

data/lib/roast/tools/update_files.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "roast/helpers/logger"
-require "diff/lcs"
-
 module Roast
   module Tools
     module UpdateFiles

data/lib/roast/tools/write_file.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "roast/helpers/logger"
-
 module Roast
   module Tools
     module WriteFile

data/lib/roast/tools.rb

@@ -1,18 +1,5 @@
 # frozen_string_literal: true
 
-require "English"
-require "fileutils"
-
-require "roast/tools/ask_user"
-require "roast/tools/bash"
-require "roast/tools/cmd"
-require "roast/tools/coding_agent"
-require "roast/tools/grep"
-require "roast/tools/read_file"
-require "roast/tools/search_file"
-require "roast/tools/update_files"
-require "roast/tools/write_file"
-
 module Roast
   module Tools
     extend self

data/lib/roast/value_objects/step_name.rb

@@ -24,12 +24,23 @@ module Roast
         @value
       end
 
+      # Enables implicit conversion to String
+      alias_method :to_str, :to_s
+
       def ==(other)
-        return false unless other.is_a?(StepName)
+        case other
+        when StepName
+          value == other.value
+        when String
+          value == other
+        else
+          false
+        end
+      end
 
-        value == other.value
+      def eql?(other)
+        other.is_a?(StepName) && value == other.value
       end
-      alias_method :eql?, :==
 
       def hash
         [self.class, @value].hash

data/lib/roast/value_objects/workflow_path.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "pathname"
-
 module Roast
   module ValueObjects
     # Value object representing a workflow file path with validation and resolution

data/lib/roast/value_objects.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "roast/value_objects/api_token"
-require "roast/value_objects/step_name"
-require "roast/value_objects/workflow_path"
-require "roast/value_objects/uri_base"
+module Roast
+  module ValueObjects
+  end
+end

data/lib/roast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.3.1"
+  VERSION = "0.4.1"
 end

data/lib/roast/workflow/agent_step.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    class AgentStep < BaseStep
+      def call
+        # For inline prompts (detected by plain text step names), use the name as the prompt
+        # For file-based steps, load from the prompt file
+        prompt_content = if name.plain_text?
+          name.to_s
+        else
+          read_sidecar_prompt
+        end
+
+        # Extract agent-specific configuration from workflow config
+        step_config = workflow.config[name.to_s] || {}
+        agent_options = {
+          include_context_summary: step_config.fetch("include_context_summary", false),
+          continue: step_config.fetch("continue", false),
+        }
+
+        # Call CodingAgent directly with the prompt content and options
+        result = Roast::Tools::CodingAgent.call(prompt_content, **agent_options)
+
+        # Process output if print_response is enabled
+        process_output(result, print_response:)
+
+        # Apply coercion if configured
+        apply_coercion(result)
+      end
+    end
+  end
+end

data/lib/roast/workflow/api_configuration.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/factories/api_provider_factory"
-require "roast/workflow/resource_resolver"
-require "roast/value_objects/uri_base"
-
 module Roast
   module Workflow
     # Handles API-related configuration including tokens and providers

data/lib/roast/workflow/base_iteration_step.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/expression_utils"
-require "roast/workflow/llm_boolean_coercer"
-require "roast/workflow/workflow_executor"
-
 module Roast
   module Workflow
     # Base class for iteration steps (RepeatStep and EachStep)
@@ -69,10 +65,11 @@ module Roast
         executor ||= WorkflowExecutor.new(context, config_hash, context_path)
         results = []
 
-        steps.each do |step|
+        steps.each_with_index do |step, index|
+          is_last_step = (index == steps.length - 1)
           result = case step
           when String
-            executor.execute_step(step)
+            executor.execute_step(step, is_last_step:)
           when Hash, Array
             executor.execute_steps([step])
           end