roast-ai 0.2.2 → 0.3.0

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module Roast
+  module Tools
+    module CodingAgent
+      module CodingAgentMessageFormatter
+        extend self
+
+        def format_messages(json)
+          messages = json.dig("message", "content")
+          messages.map(&method(:format_message))
+        end
+
+        private
+
+        def format_message(message)
+          case message["type"]
+          when "text"
+            format_text(message["text"])
+          when "tool_use"
+            name = message["name"]
+            input = message["input"].except("description", "old_string", "new_string")
+            case name
+            when "Task"
+              "→ #{name}#{format_task_input(input)}"
+            when "TodoWrite"
+              "→ #{name}#{format_todo_write_input(input)}"
+            when "Bash", "Read", "Edit"
+              "→ #{name}(#{format_arguments(input)})"
+            else
+              "→ #{name} #{format_text(input.to_yaml)}"
+            end
+          when "tool_result"
+            # Ignore these message types
+          else
+            message.except("id").to_yaml
+          end
+        end
+
+        def format_text(text)
+          text.lines.map do |line|
+            "\t#{line}"
+          end.join.lstrip
+        end
+
+        def format_task_input(input)
+          prompt = input["prompt"].lines.filter { |line| !line.blank? }.map { |line| "\t#{line}" }.join
+          args = format_arguments(input.except("prompt"))
+          "(#{args})\n#{prompt}"
+        end
+
+        def format_todo_write_input(input)
+          todos = input["todos"].map(&method(:format_todo_write_input_item)).join("\n")
+          args = format_arguments(input.except("todos"))
+          "(#{args})\n#{todos}"
+        end
+
+        def format_todo_write_input_item(item)
+          id = item["id"]
+          content = item["content"]
+          status = case item["status"]
+          when "pending"
+            "[ ]"
+          when "in_progress"
+            "[-]"
+          when "completed"
+            "[x]"
+          end
+          "\t#{id}. #{status} #{content}"
+        end
+
+        def format_arguments(arguments)
+          if arguments.length == 1
+            arguments.first[1].to_json
+          else
+            arguments.map do |key, value|
+              "#{key}: #{value.to_json}"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/tools/search_file.rb

@@ -15,7 +15,7 @@ module Roast
               :search_for_file,
               "Search for a file in the project using a glob pattern.",
               glob_pattern: { type: "string", description: "A glob pattern to search for. Example: 'test/**/*_test.rb'" },
-              path: { type: "string", description: "path to search from" },
+              path: { type: "string", description: "path to search from", default: "." },
             ) do |params|
               Roast::Tools::SearchFile.call(params[:glob_pattern], params[:path]).tap do |result|
                 Roast::Helpers::Logger.debug(result) if ENV["DEBUG"]
@@ -26,6 +26,18 @@ module Roast
       end
 
       def call(glob_pattern, path = ".")
+        raise ArgumentError, "glob_pattern is required" if glob_pattern.nil?
+
+        path ||= "."
+
+        unless File.exist?(path)
+          Roast::Helpers::Logger.error("Path does not exist: #{path}")
+          return "Path does not exist: #{path}"
+        end
+
+        # prefix **/ to the glob pattern if it doesn't already have it
+        glob_pattern = "**/#{glob_pattern}" unless glob_pattern.start_with?("**")
+
         Roast::Helpers::Logger.info("🔍 Searching for: '#{glob_pattern}' in '#{File.expand_path(path)}'\n")
         search_for(glob_pattern, path).then do |results|
           return "No results found for #{glob_pattern} in #{path}" if results.empty?

data/lib/roast/tools.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require "active_support/cache"
 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/write_file"
 require "roast/tools/update_files"
-require "roast/tools/cmd"
-require "roast/tools/coding_agent"
-require "roast/tools/ask_user"
+require "roast/tools/write_file"
 
 module Roast
   module Tools

data/lib/roast/version.rb

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

data/lib/roast/workflow/base_iteration_step.rb

@@ -12,11 +12,12 @@ module Roast
 
       DEFAULT_MAX_ITERATIONS = 100
 
-      attr_reader :steps
+      attr_reader :steps, :config_hash
 
-      def initialize(workflow, steps:, **kwargs)
+      def initialize(workflow, steps:, config_hash: {}, **kwargs)
         super(workflow, **kwargs)
         @steps = steps
+        @config_hash = config_hash
         # Don't initialize cmd_tool here - we'll do it lazily when needed
       end
 
@@ -65,7 +66,7 @@ module Roast
 
       # Execute nested steps
       def execute_nested_steps(steps, context, executor = nil)
-        executor ||= WorkflowExecutor.new(context, {}, context_path)
+        executor ||= WorkflowExecutor.new(context, config_hash, context_path)
         results = []
 
         steps.each do |step|
@@ -139,7 +140,7 @@ module Roast
       # Execute a step by name and return its result
       def execute_step_by_name(step_name, context)
         # Reuse existing step execution logic
-        executor = WorkflowExecutor.new(context, {}, context_path)
+        executor = WorkflowExecutor.new(context, config_hash, context_path)
         executor.execute_step(step_name)
       end
 

data/lib/roast/workflow/base_step.rb

@@ -9,20 +9,20 @@ module Roast
     class BaseStep
       extend Forwardable
 
-      attr_accessor :model, :print_response, :auto_loop, :json, :params, :resource, :coerce_to
+      attr_accessor :model, :print_response, :json, :params, :resource, :coerce_to
       attr_reader :workflow, :name, :context_path
 
       def_delegator :workflow, :append_to_final_output
       def_delegator :workflow, :chat_completion
       def_delegator :workflow, :transcript
 
-      def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil, auto_loop: true)
+      # TODO: is this really the model we want to default to, and is this the right place to set it?
+      def initialize(workflow, model: "anthropic:claude-opus-4", name: nil, context_path: nil)
         @workflow = workflow
         @model = model
         @name = name || self.class.name.underscore.split("/").last
         @context_path = context_path || ContextPathResolver.resolve(self.class)
         @print_response = false
-        @auto_loop = auto_loop
         @json = false
         @params = {}
         @coerce_to = nil
@@ -31,7 +31,7 @@ module Roast
 
       def call
         prompt(read_sidecar_prompt)
-        result = chat_completion(print_response:, auto_loop:, json:, params:)
+        result = chat_completion(print_response:, json:, params:)
 
         # Apply coercion if configured
         apply_coercion(result)
@@ -39,25 +39,24 @@ module Roast
 
       protected
 
-      def chat_completion(print_response: nil, auto_loop: nil, json: nil, params: nil)
+      def chat_completion(print_response: nil, json: nil, params: nil)
         # Use instance variables as defaults if parameters are not provided
         print_response = @print_response if print_response.nil?
-        auto_loop = @auto_loop if auto_loop.nil?
         json = @json if json.nil?
         params = @params if params.nil?
 
-        workflow.chat_completion(openai: workflow.openai? && model, loop: auto_loop, model: model, json:, params:).then do |response|
-          case response
-          in Array if json
-            response.flatten.first
-          in Array
-            # For non-JSON responses, join array elements
-            response.map(&:presence).compact.join("\n")
-          else
-            response
+        workflow.chat_completion(openai: workflow.openai? && model, model: model, json:, params:).tap do |result|
+          process_output(result, print_response:)
+
+          begin
+            if json
+              return nil if result.strip.empty? # Explicitly handle empty string
+
+              return JSON.parse(result)
+            end
+          rescue JSON::ParserError
+            # If JSON parsing fails, leave it as a string
           end
-        end.tap do |response|
-          process_output(response, print_response:)
         end
       end
 
@@ -90,11 +89,11 @@ module Roast
       private
 
       def apply_coercion(result)
-        return result unless @coerce_to
-
         case @coerce_to
         when :boolean
-          # Simple boolean coercion
+          # Simple boolean coercion - empty string is false
+          return false if result.nil? || result == ""
+
           !!result
         when :llm_boolean
           # Use LLM boolean coercer for natural language responses
@@ -104,9 +103,19 @@ module Roast
           # Ensure result is iterable
           return result if result.respond_to?(:each)
 
+          # Try to parse as JSON array first
+          if result.is_a?(String) && result.strip.start_with?("[")
+            begin
+              parsed = JSON.parse(result)
+              return parsed if parsed.is_a?(Array)
+            rescue JSON::ParserError
+              # Fall through to split by newlines
+            end
+          end
+
           result.to_s.split("\n")
         else
-          # Unknown coercion type, return as-is
+          # Unknown or nil coercion type, return as-is
           result
         end
       end

data/lib/roast/workflow/base_workflow.rb

@@ -2,12 +2,10 @@
 
 require "raix/chat_completion"
 require "raix/function_dispatch"
-require "active_support"
-require "active_support/isolated_execution_state"
-require "active_support/notifications"
-require "active_support/core_ext/hash/indifferent_access"
-require "roast/workflow/output_manager"
+
 require "roast/workflow/context_path_resolver"
+require "roast/workflow/dot_access_hash"
+require "roast/workflow/output_manager"
 
 module Roast
   module Workflow
@@ -24,22 +22,22 @@ module Roast
         :resource,
         :session_name,
         :session_timestamp,
-        :configuration,
-        :model
+        :model,
+        :workflow_configuration
 
       attr_reader :pre_processing_data
 
-      delegate :api_provider, :openai?, to: :configuration
+      delegate :api_provider, :openai?, to: :workflow_configuration, allow_nil: true
       delegate :output, :output=, :append_to_final_output, :final_output, to: :output_manager
 
-      def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, configuration: nil, pre_processing_data: nil)
+      def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, workflow_configuration: nil, pre_processing_data: nil)
         @file = file
         @name = name || self.class.name.underscore.split("/").last
         @context_path = context_path || ContextPathResolver.resolve(self.class)
         @resource = resource || Roast::Resources.for(file)
         @session_name = session_name || @name
         @session_timestamp = nil
-        @configuration = configuration
+        @workflow_configuration = workflow_configuration
         @pre_processing_data = pre_processing_data ? DotAccessHash.new(pre_processing_data).freeze : nil
 
         # Initialize managers

data/lib/roast/workflow/configuration.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
 require "roast/workflow/api_configuration"
 require "roast/workflow/configuration_loader"
 require "roast/workflow/resource_resolver"
@@ -11,7 +10,9 @@ module Roast
     # Encapsulates workflow configuration data and provides structured access
     # to the configuration settings
     class Configuration
-      attr_reader :config_hash, :workflow_path, :name, :steps, :pre_processing, :post_processing, :tools, :function_configs, :model, :resource
+      MCPTool = Struct.new(:name, :config, :only, :except, keyword_init: true)
+
+      attr_reader :config_hash, :workflow_path, :name, :steps, :pre_processing, :post_processing, :tools, :tool_configs, :mcp_tools, :function_configs, :model, :resource
       attr_accessor :target
 
       delegate :api_provider, :openrouter?, :openai?, :uri_base, to: :api_configuration
@@ -32,7 +33,8 @@ module Roast
         @steps = ConfigurationLoader.extract_steps(@config_hash)
         @pre_processing = ConfigurationLoader.extract_pre_processing(@config_hash)
         @post_processing = ConfigurationLoader.extract_post_processing(@config_hash)
-        @tools = ConfigurationLoader.extract_tools(@config_hash)
+        @tools, @tool_configs = ConfigurationLoader.extract_tools(@config_hash)
+        @mcp_tools = ConfigurationLoader.extract_mcp_tools(@config_hash)
         @function_configs = ConfigurationLoader.extract_functions(@config_hash)
         @model = ConfigurationLoader.extract_model(@config_hash)
 
@@ -82,6 +84,13 @@ module Roast
         @function_configs[function_name.to_s] || {}
       end
 
+      # Get configuration for a specific tool
+      # @param tool_name [String] The name of the tool (e.g., 'Roast::Tools::Cmd')
+      # @return [Hash] The configuration for the tool or empty hash if not found
+      def tool_config(tool_name)
+        @tool_configs[tool_name.to_s] || {}
+      end
+
       private
 
       attr_reader :api_configuration

data/lib/roast/workflow/configuration_loader.rb

@@ -12,7 +12,21 @@ module Roast
         # @return [Hash] The parsed configuration hash
         def load(workflow_path)
           validate_path!(workflow_path)
-          config_hash = YAML.load_file(workflow_path)
+
+          # Load shared.yml if it exists one level above
+          parent_dir = File.dirname(workflow_path)
+          shared_path = File.join(parent_dir, "..", "shared.yml")
+
+          yaml_content = ""
+
+          if File.exist?(shared_path)
+            yaml_content += File.read(shared_path)
+            yaml_content += "\n"
+          end
+
+          yaml_content += File.read(workflow_path)
+          config_hash = YAML.load(yaml_content, aliases: true)
+
           validate_config!(config_hash)
           config_hash
         end
@@ -46,11 +60,56 @@ module Roast
           config_hash["post_processing"] || []
         end
 
-        # Extract tools from the configuration
+        # Extract tools and tool configurations from the configuration
         # @param config_hash [Hash] The configuration hash
-        # @return [Array] The tools array or empty array
+        # @return [Array, Hash] The tools array or empty array
         def extract_tools(config_hash)
-          config_hash["tools"] || []
+          tools_config = config_hash["tools"] || []
+          tools = []
+          tool_configs = {}
+
+          tools_config.each do |tool_entry|
+            case tool_entry
+            when String
+              tools << tool_entry
+            when Hash
+              tool_entry.each do |tool_name, config|
+                # Skip MCP tool configurations (those with url or command)
+                if config.is_a?(Hash) && (config["url"] || config["command"])
+                  next
+                end
+
+                tools << tool_name
+                tool_configs[tool_name] = config || {}
+              end
+            end
+          end
+
+          [tools, tool_configs]
+        end
+
+        # Extract MCP tools from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The MCP tools array or empty array
+        def extract_mcp_tools(config_hash)
+          tools = config_hash["tools"]&.select { |tool| tool.is_a?(Hash) } || []
+          return [] if tools.none?
+
+          mcp_tools = []
+          tools.each do |tool|
+            tool.each do |tool_name, config|
+              next unless config.is_a?(Hash) && (config["url"] || config["command"])
+
+              mcp_tools << Configuration::MCPTool.new(
+                name: tool_name,
+                config: config,
+                only: config["only"],
+                except: config["except"],
+              )
+            end
+          end
+
+          mcp_tools
         end
 
         # Extract function configurations

data/lib/roast/workflow/configuration_parser.rb

@@ -3,9 +3,6 @@
 require "roast/workflow/configuration"
 require "roast/workflow/workflow_initializer"
 require "roast/workflow/workflow_runner"
-require "active_support"
-require "active_support/isolated_execution_state"
-require "active_support/notifications"
 
 module Roast
   module Workflow

data/lib/roast/workflow/error_handler.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/notifications"
 require "roast/helpers/logger"
 require "roast/workflow/command_executor"
 

data/lib/roast/workflow/file_state_repository.rb

@@ -79,7 +79,6 @@ module Roast
         )
         output_file = File.join(session_dir, "final_output.txt")
         File.write(output_file, output_content)
-        $stderr.puts "Final output saved to: #{output_file}"
         output_file
       rescue => e
         $stderr.puts "Failed to save final output: #{e.message}"

data/lib/roast/workflow/iteration_executor.rb

@@ -4,10 +4,11 @@ module Roast
   module Workflow
     # Handles execution of iteration steps (repeat and each)
     class IterationExecutor
-      def initialize(workflow, context_path, state_manager)
+      def initialize(workflow, context_path, state_manager, config_hash = {})
         @workflow = workflow
         @context_path = context_path
         @state_manager = state_manager
+        @config_hash = config_hash
       end
 
       def execute_repeat(repeat_config)
@@ -31,6 +32,7 @@ module Roast
           max_iterations: max_iterations,
           name: "repeat_#{@workflow.output.size}",
           context_path: @context_path,
+          config_hash: @config_hash,
         )
 
         # Apply configuration if provided
@@ -70,6 +72,7 @@ module Roast
           steps: steps,
           name: "each_#{variable_name}",
           context_path: @context_path,
+          config_hash: @config_hash,
         )
 
         # Apply configuration if provided
@@ -92,7 +95,6 @@ module Roast
       # Apply configuration settings to a step
       def apply_step_configuration(step, step_config)
         step.print_response = step_config["print_response"] if step_config.key?("print_response")
-        step.auto_loop = step_config["loop"] if step_config.key?("loop")
         step.json = step_config["json"] if step_config.key?("json")
         step.params = step_config["params"] if step_config.key?("params")
         step.model = step_config["model"] if step_config.key?("model")

data/lib/roast/workflow/output_manager.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/indifferent_access"
 require "roast/workflow/dot_access_hash"
 
 module Roast

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -207,7 +207,8 @@ module Roast
           exit_on_error = context.exit_on_error?(interpolated_name)
 
           # Execute the command directly using the appropriate executor
-          result = execute(interpolated_command, { exit_on_error: exit_on_error })
+          # Pass the original key name for configuration lookup
+          result = execute(interpolated_command, { exit_on_error: exit_on_error, step_key: interpolated_name })
           context.workflow.output[interpolated_name] = result
           result
         end
@@ -227,13 +228,14 @@ module Roast
           execute_command_step(interpolated_step, { exit_on_error: exit_on_error })
         else
           exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
-          execute_standard_step(interpolated_step, { exit_on_error: exit_on_error })
+          execute_standard_step(interpolated_step, options.merge(exit_on_error: exit_on_error))
         end
       end
 
       def execute_standard_step(step, options)
         exit_on_error = options.fetch(:exit_on_error, true)
-        step_orchestrator.execute_step(step, exit_on_error: exit_on_error)
+        step_key = options[:step_key]
+        step_orchestrator.execute_step(step, exit_on_error: exit_on_error, step_key: step_key)
       end
 
       def validate_each_step!(step)

data/lib/roast/workflow/step_executors/hash_step_executor.rb

@@ -24,7 +24,7 @@ module Roast
             step_config = config_hash[interpolated_name]
             exit_on_error = step_config.is_a?(Hash) ? step_config.fetch("exit_on_error", true) : true
 
-            workflow.output[interpolated_name] = step_runner.execute_step(interpolated_command, exit_on_error: exit_on_error)
+            workflow.output[interpolated_name] = step_runner.execute_step(interpolated_command, exit_on_error: exit_on_error, step_key: interpolated_name)
           end
         end
 

data/lib/roast/workflow/step_loader.rb

@@ -46,25 +46,32 @@ module Roast
       # Finds and loads a step by name
       #
       # @param step_name [String, StepName] The name of the step to load
+      # @param step_key [String] The configuration key for the step (optional)
       # @return [BaseStep] The loaded step instance
-      def load(step_name)
+      def load(step_name, step_key: nil)
         name = step_name.is_a?(Roast::ValueObjects::StepName) ? step_name : Roast::ValueObjects::StepName.new(step_name)
 
+        # Get step config for per-step path
+        step_config = config_hash[name.to_s] || {}
+        per_step_path = step_config["path"]
+
         # First check for a prompt step (contains spaces)
         if name.plain_text?
-          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s, auto_loop: true)
-          configure_step(step, name.to_s)
+          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s)
+          # Use step_key for configuration if provided, otherwise use name
+          config_key = step_key || name.to_s
+          configure_step(step, config_key)
           return step
         end
 
         # Look for Ruby file in various locations
-        step_file_path = find_step_file(name.to_s)
+        step_file_path = find_step_file(name.to_s, per_step_path)
         if step_file_path
           return load_ruby_step(step_file_path, name.to_s)
         end
 
         # Look for step directory
-        step_directory = find_step_directory(name.to_s)
+        step_directory = find_step_directory(name.to_s, per_step_path)
         unless step_directory
           raise StepNotFoundError.new("Step directory or file not found: #{name}", step_name: name.to_s)
         end
@@ -74,8 +81,22 @@ module Roast
 
       private
 
+      def resolve_path(path)
+        return unless path
+        return path if Pathname.new(path).absolute?
+
+        File.expand_path(path, context_path)
+      end
+
       # Find a Ruby step file in various locations
-      def find_step_file(step_name)
+      def find_step_file(step_name, per_step_path = nil)
+        # Check in per-step path first
+        if per_step_path
+          resolved_per_step_path = resolve_path(per_step_path)
+          custom_rb_path = File.join(resolved_per_step_path, "#{step_name}.rb")
+          return custom_rb_path if File.file?(custom_rb_path)
+        end
+
         # Check in phase-specific directory first
         if phase != :steps
           phase_rb_path = File.join(context_path, phase.to_s, "#{step_name}.rb")
@@ -94,7 +115,14 @@ module Roast
       end
 
       # Find a step directory
-      def find_step_directory(step_name)
+      def find_step_directory(step_name, per_step_path = nil)
+        # Check in per-step path first
+        if per_step_path
+          resolved_per_step_path = resolve_path(per_step_path)
+          custom_step_path = File.join(resolved_per_step_path, step_name)
+          return custom_step_path if File.directory?(custom_step_path)
+        end
+
         # Check in phase-specific directory first
         if phase != :steps
           phase_step_path = File.join(context_path, phase.to_s, step_name)
@@ -158,7 +186,6 @@ module Roast
       # Apply configuration settings to a step
       def apply_step_configuration(step, step_config)
         step.print_response = step_config["print_response"] if step_config.key?("print_response")
-        step.auto_loop = step_config["loop"] if step_config.key?("loop")
         step.json = step_config["json"] if step_config.key?("json")
         step.params = step_config["params"] if step_config.key?("params")
         step.coerce_to = step_config["coerce_to"].to_sym if step_config.key?("coerce_to")

data/lib/roast/workflow/step_orchestrator.rb

@@ -22,13 +22,15 @@ module Roast
         @workflow_executor = workflow_executor
       end
 
-      def execute_step(name, exit_on_error: true)
+      def execute_step(name, exit_on_error: true, step_key: nil)
         resource_type = @workflow.respond_to?(:resource) ? @workflow.resource&.type : nil
 
         @error_handler.with_error_handling(name, resource_type: resource_type) do
           $stderr.puts "Executing: #{name} (Resource type: #{resource_type || "unknown"})"
 
-          step_object = @step_loader.load(name)
+          # Use step_key for loading if provided, otherwise use name
+          load_key = step_key || name
+          step_object = @step_loader.load(name, step_key: load_key)
           step_result = step_object.call
 
           # Store result in workflow output