roast-ai 0.1.7 → 0.2.1

data/lib/roast/workflow/command_executor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "English"
+
+module Roast
+  module Workflow
+    class CommandExecutor
+      class CommandExecutionError < StandardError
+        attr_reader :command, :exit_status, :original_error
+
+        def initialize(message, command:, exit_status: nil, original_error: nil)
+          @command = command
+          @exit_status = exit_status
+          @original_error = original_error
+          super(message)
+        end
+      end
+
+      def initialize(logger: nil)
+        @logger = logger || NullLogger.new
+      end
+
+      def execute(command_string, exit_on_error: true)
+        command = extract_command(command_string)
+
+        output = %x(#{command})
+        exit_status = $CHILD_STATUS.exitstatus
+
+        handle_execution_result(
+          command: command,
+          output: output,
+          exit_status: exit_status,
+          success: $CHILD_STATUS.success?,
+          exit_on_error: exit_on_error,
+        )
+      rescue ArgumentError, CommandExecutionError
+        raise
+      rescue => e
+        handle_execution_error(
+          command: command,
+          error: e,
+          exit_on_error: exit_on_error,
+        )
+      end
+
+      private
+
+      def extract_command(command_string)
+        match = command_string.strip.match(/^\$\((.*)\)$/)
+        raise ArgumentError, "Invalid command format. Expected $(command), got: #{command_string}" unless match
+
+        match[1]
+      end
+
+      def handle_execution_result(command:, output:, exit_status:, success:, exit_on_error:)
+        return output if success
+
+        if exit_on_error
+          raise CommandExecutionError.new(
+            "Command exited with non-zero status (#{exit_status})",
+            command: command,
+            exit_status: exit_status,
+          )
+        else
+          @logger.warn("Command '#{command}' exited with non-zero status (#{exit_status}), continuing execution")
+          output + "\n[Exit status: #{exit_status}]"
+        end
+      end
+
+      def handle_execution_error(command:, error:, exit_on_error:)
+        if exit_on_error
+          raise CommandExecutionError.new(
+            "Failed to execute command '#{command}': #{error.message}",
+            command: command,
+            original_error: error,
+          )
+        else
+          @logger.warn("Command '#{command}' failed with error: #{error.message}, continuing execution")
+          "Error executing command: #{error.message}\n[Exit status: error]"
+        end
+      end
+
+      class NullLogger
+        def warn(_message); end
+      end
+    end
+  end
+end

data/lib/roast/workflow/conditional_executor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Handles execution of conditional steps (if and unless)
+    class ConditionalExecutor
+      def initialize(workflow, context_path, state_manager, workflow_executor = nil)
+        @workflow = workflow
+        @context_path = context_path
+        @state_manager = state_manager
+        @workflow_executor = workflow_executor
+      end
+
+      def execute_conditional(conditional_config)
+        $stderr.puts "Executing conditional step: #{conditional_config.inspect}"
+
+        # Determine if this is an 'if' or 'unless' condition
+        condition_expr = conditional_config["if"] || conditional_config["unless"]
+        is_unless = conditional_config.key?("unless")
+        then_steps = conditional_config["then"]
+
+        # Verify required parameters
+        raise WorkflowExecutor::ConfigurationError, "Missing condition in conditional configuration" unless condition_expr
+        raise WorkflowExecutor::ConfigurationError, "Missing 'then' steps in conditional configuration" unless then_steps
+
+        # Create and execute a ConditionalStep
+        require "roast/workflow/conditional_step" unless defined?(Roast::Workflow::ConditionalStep)
+        conditional_step = ConditionalStep.new(
+          @workflow,
+          config: conditional_config,
+          name: "conditional_#{condition_expr.gsub(/[^a-zA-Z0-9_]/, "_")[0..20]}",
+          context_path: @context_path,
+          workflow_executor: @workflow_executor,
+        )
+
+        result = conditional_step.call
+
+        # Store a marker in workflow output to indicate which branch was taken
+        condition_key = is_unless ? "unless" : "if"
+        step_name = "#{condition_key}_#{condition_expr.gsub(/[^a-zA-Z0-9_]/, "_")[0..30]}"
+        @workflow.output[step_name] = result
+
+        # Save state
+        @state_manager.save_state(step_name, @workflow.output[step_name])
+
+        result
+      end
+    end
+  end
+end

data/lib/roast/workflow/conditional_step.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "roast/workflow/base_step"
+require "roast/workflow/expression_evaluator"
+require "roast/workflow/interpolator"
+
+module Roast
+  module Workflow
+    class ConditionalStep < BaseStep
+      include ExpressionEvaluator
+
+      def initialize(workflow, config:, name:, context_path:, workflow_executor:, **kwargs)
+        super(workflow, name: name, context_path: context_path, **kwargs)
+
+        @config = config
+        @condition = config["if"] || config["unless"]
+        @is_unless = config.key?("unless")
+        @then_steps = config["then"] || []
+        @else_steps = config["else"] || []
+        @workflow_executor = workflow_executor
+      end
+
+      def call
+        # Evaluate the condition
+        condition_result = evaluate_condition(@condition)
+
+        # Invert the result if this is an 'unless' condition
+        condition_result = !condition_result if @is_unless
+
+        # Select which steps to execute based on the condition
+        steps_to_execute = condition_result ? @then_steps : @else_steps
+
+        # Execute the selected steps
+        unless steps_to_execute.empty?
+          @workflow_executor.execute_steps(steps_to_execute)
+        end
+
+        # Return a result indicating which branch was taken
+        { condition_result: condition_result, branch_executed: condition_result ? "then" : "else" }
+      end
+
+      private
+
+      def evaluate_condition(condition)
+        return false unless condition.is_a?(String)
+
+        if ruby_expression?(condition)
+          # For conditionals, coerce result to boolean
+          !!evaluate_ruby_expression(condition)
+        elsif bash_command?(condition)
+          evaluate_bash_command(condition, for_condition: true)
+        else
+          # Treat as a step name or direct boolean
+          evaluate_step_or_value(condition, for_condition: true)
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/configuration.rb

@@ -1,55 +1,46 @@
 # frozen_string_literal: true
 
-require "open3"
-require "yaml"
+require "active_support/core_ext/module/delegation"
+require "roast/workflow/api_configuration"
+require "roast/workflow/configuration_loader"
+require "roast/workflow/resource_resolver"
+require "roast/workflow/step_finder"
 
 module Roast
   module Workflow
     # Encapsulates workflow configuration data and provides structured access
     # to the configuration settings
     class Configuration
-      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :api_token, :api_provider, :model, :resource
+      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :model, :resource
       attr_accessor :target
 
-      def initialize(workflow_path, options = {})
-        @workflow_path = workflow_path
-        @config_hash = YAML.load_file(workflow_path)
-
-        # Extract key configuration values
-        @name = @config_hash["name"] || File.basename(workflow_path, ".yml")
-        @steps = @config_hash["steps"] || []
+      delegate :api_provider, :openrouter?, :openai?, to: :api_configuration
 
-        # Process tools configuration
-        parse_tools
-
-        # Process function-specific configurations
-        parse_functions
-
-        # Read the target parameter
-        @target = options[:target] || @config_hash["target"]
+      # Delegate api_token to effective_token for backward compatibility
+      def api_token
+        @api_configuration.effective_token
+      end
 
-        # Process the target command if it's a shell command
-        @target = process_target(@target) if has_target?
+      def initialize(workflow_path, options = {})
+        @workflow_path = workflow_path
 
-        # Create the appropriate resource object for the target
-        if defined?(Roast::Resources)
-          @resource = if has_target?
-            Roast::Resources.for(@target)
-          else
-            Roast::Resources::NoneResource.new(nil)
-          end
-        end
+        # Load configuration using ConfigurationLoader
+        @config_hash = ConfigurationLoader.load(workflow_path)
 
-        # Process API token if provided
-        if @config_hash["api_token"]
-          @api_token = process_shell_command(@config_hash["api_token"])
-        end
+        # Extract basic configuration values
+        @name = ConfigurationLoader.extract_name(@config_hash, workflow_path)
+        @steps = ConfigurationLoader.extract_steps(@config_hash)
+        @tools = ConfigurationLoader.extract_tools(@config_hash)
+        @function_configs = ConfigurationLoader.extract_functions(@config_hash)
+        @model = ConfigurationLoader.extract_model(@config_hash)
 
-        # Determine API provider (defaults to OpenAI if not specified)
-        @api_provider = determine_api_provider
+        # Initialize components
+        @api_configuration = ApiConfiguration.new(@config_hash)
+        @step_finder = StepFinder.new(@steps)
 
-        # Extract default model if provided
-        @model = @config_hash["model"]
+        # Process target and resource
+        @target = ConfigurationLoader.extract_target(@config_hash, options)
+        process_resource
       end
 
       def context_path
@@ -76,62 +67,10 @@ module Roast
         # Handle different call patterns for backward compatibility
         if steps_array.is_a?(String) && target_step.nil?
           target_step = steps_array
-          steps_array = steps
-        elsif steps_array.is_a?(Array) && target_step.is_a?(String)
-          # This is the normal case - steps_array and target_step are provided
-        else
-          # Default to self.steps if just the target_step is provided
-          steps_array = steps
+          steps_array = nil
         end
 
-        # First, try using the new more detailed search
-        steps_array.each_with_index do |step, index|
-          case step
-          when Hash
-            # Could be {name: command} or {name: {substeps}}
-            step_key = step.keys.first
-            return index if step_key == target_step
-          when Array
-            # This is a parallel step container, search inside it
-            found = step.any? do |substep|
-              case substep
-              when Hash
-                substep.keys.first == target_step
-              when String
-                substep == target_step
-              else
-                false
-              end
-            end
-            return index if found
-          when String
-            return index if step == target_step
-          end
-        end
-
-        # Fall back to the original method using extract_step_name
-        steps_array.each_with_index do |step, index|
-          step_name = extract_step_name(step)
-          if step_name.is_a?(Array)
-            # For arrays (parallel steps), check if target is in the array
-            return index if step_name.flatten.include?(target_step)
-          elsif step_name == target_step
-            return index
-          end
-        end
-
-        nil
-      end
-
-      # Returns an array of all tool class names
-      def parse_tools
-        # Only support array format: ["Roast::Tools::Grep", "Roast::Tools::ReadFile"]
-        @tools = @config_hash["tools"] || []
-      end
-
-      # Parse function-specific configurations
-      def parse_functions
-        @function_configs = @config_hash["functions"] || {}
+        @step_finder.find_index(target_step, steps_array)
       end
 
       # Get configuration for a specific function
@@ -141,77 +80,15 @@ module Roast
         @function_configs[function_name.to_s] || {}
       end
 
-      def openrouter?
-        @api_provider == :openrouter
-      end
-
-      def openai?
-        @api_provider == :openai
-      end
-
       private
 
-      def determine_api_provider
-        return :openai unless @config_hash["api_provider"]
-
-        provider = @config_hash["api_provider"].to_s.downcase
-
-        case provider
-        when "openai"
-          :openai
-        when "openrouter"
-          :openrouter
-        else
-          Roast::Helpers::Logger.warn("Unknown API provider '#{provider}', defaulting to OpenAI")
-          :openai
-        end
-      end
-
-      def process_shell_command(command)
-        # If it's a bash command with the $(command) syntax
-        if command =~ /^\$\((.*)\)$/
-          return Open3.capture2e({}, ::Regexp.last_match(1)).first.strip
-        end
-
-        # Legacy % prefix for backward compatibility
-        if command.start_with?("% ")
-          return Open3.capture2e({}, *command.split(" ")[1..-1]).first.strip
-        end
-
-        # Not a shell command, return as is
-        command
-      end
-
-      def process_target(command)
-        # Process shell command first
-        processed = process_shell_command(command)
-
-        # If it's a glob pattern, return the full paths of the files it matches
-        if processed.include?("*")
-          matched_files = Dir.glob(processed)
-          # If no files match, return the pattern itself
-          return processed if matched_files.empty?
-
-          return matched_files.map { |file| File.expand_path(file) }.join("\n")
-        end
-
-        # For tests, if the command was already processed as a shell command and is simple,
-        # don't expand the path to avoid breaking existing tests
-        return processed if command != processed && !processed.include?("/")
+      attr_reader :api_configuration
 
-        # assumed to be a direct file path(s)
-        File.expand_path(processed)
-      end
-
-      def extract_step_name(step)
-        case step
-        when String
-          step
-        when Hash
-          step.keys.first
-        when Array
-          # For arrays, we'll need special handling as they contain multiple steps
-          step.map { |s| extract_step_name(s) }
+      def process_resource
+        if defined?(Roast::Resources)
+          @resource = ResourceResolver.resolve(@target, context_path)
+          # Update target with processed value for backward compatibility
+          @target = @resource.value if has_target?
         end
       end
     end

data/lib/roast/workflow/configuration_loader.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Roast
+  module Workflow
+    # Handles loading and parsing of workflow configuration files
+    class ConfigurationLoader
+      class << self
+        # Load configuration from a YAML file
+        # @param workflow_path [String] Path to the workflow YAML file
+        # @return [Hash] The parsed configuration hash
+        def load(workflow_path)
+          validate_path!(workflow_path)
+          config_hash = YAML.load_file(workflow_path)
+          validate_config!(config_hash)
+          config_hash
+        end
+
+        # Extract the workflow name from config or path
+        # @param config_hash [Hash] The configuration hash
+        # @param workflow_path [String] Path to the workflow file
+        # @return [String] The workflow name
+        def extract_name(config_hash, workflow_path)
+          config_hash["name"] || File.basename(workflow_path, ".yml")
+        end
+
+        # Extract steps from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The steps array or empty array
+        def extract_steps(config_hash)
+          config_hash["steps"] || []
+        end
+
+        # Extract tools from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [Array] The tools array or empty array
+        def extract_tools(config_hash)
+          config_hash["tools"] || []
+        end
+
+        # Extract function configurations
+        # @param config_hash [Hash] The configuration hash
+        # @return [Hash] The functions configuration or empty hash
+        def extract_functions(config_hash)
+          config_hash["functions"] || {}
+        end
+
+        # Extract model from the configuration
+        # @param config_hash [Hash] The configuration hash
+        # @return [String, nil] The model name if specified
+        def extract_model(config_hash)
+          config_hash["model"]
+        end
+
+        # Extract target from config or options
+        # @param config_hash [Hash] The configuration hash
+        # @param options [Hash] Runtime options
+        # @return [String, nil] The target if specified
+        def extract_target(config_hash, options = {})
+          options[:target] || config_hash["target"]
+        end
+
+        private
+
+        def validate_path!(workflow_path)
+          raise ArgumentError, "Workflow path cannot be nil" if workflow_path.nil?
+          raise ArgumentError, "Workflow file not found: #{workflow_path}" unless File.exist?(workflow_path)
+          raise ArgumentError, "Workflow path must be a YAML file" unless workflow_path.end_with?(".yml", ".yaml")
+        end
+
+        def validate_config!(config_hash)
+          raise ArgumentError, "Invalid workflow configuration" unless config_hash.is_a?(Hash)
+        end
+      end
+    end
+  end
+end