roast-ai 0.3.1 → 0.4.1

data/lib/roast/workflow/state_repository_factory.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Factory for creating the appropriate StateRepository implementation
+    class StateRepositoryFactory
+      class << self
+        def create(type = nil)
+          type ||= default_type
+
+          case type.to_s
+          when "sqlite"
+            # Lazy load the SQLite repository only when needed
+            Roast::Workflow::SqliteStateRepository.new
+          when "file", "filesystem"
+            Roast::Workflow::FileStateRepository.new
+          else
+            raise ArgumentError, "Unknown state repository type: #{type}. Valid types are: sqlite, file"
+          end
+        end
+
+        private
+
+        def default_type
+          # Check environment variable first (for backwards compatibility)
+          if ENV["ROAST_STATE_STORAGE"]
+            ENV["ROAST_STATE_STORAGE"].downcase
+          else
+            # Default to SQLite for better functionality
+            "sqlite"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_completion_reporter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Reports step completion with token consumption information
+    class StepCompletionReporter
+      def initialize(output: $stderr)
+        @output = output
+      end
+
+      def report(step_name, tokens_consumed, total_tokens)
+        formatted_consumed = number_with_delimiter(tokens_consumed)
+        formatted_total = number_with_delimiter(total_tokens)
+
+        @output.puts "✓ Complete: #{step_name} (consumed #{formatted_consumed} tokens, total #{formatted_total})"
+        @output.puts
+        @output.puts
+      end
+
+      private
+
+      def number_with_delimiter(number)
+        number.to_s.gsub(/(\d)(?=(\d{3})+(?!\d))/, '\\1,')
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_executor_coordinator.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/case_executor"
-require "roast/workflow/conditional_executor"
-require "roast/workflow/step_executor_factory"
-require "roast/workflow/step_type_resolver"
-
 module Roast
   module Workflow
     # Coordinates the execution of different types of steps
@@ -29,20 +24,21 @@ module Roast
 
       # Execute a list of steps
       def execute_steps(workflow_steps)
-        workflow_steps.each do |step|
+        workflow_steps.each_with_index do |step, index|
+          is_last_step = (index == workflow_steps.length - 1)
           case step
           when Hash
-            execute(step)
+            execute(step, is_last_step:)
           when Array
-            execute(step)
+            execute(step, is_last_step:)
           when String
-            execute(step)
+            execute(step, is_last_step:)
             # Handle pause after string steps
             if @context.workflow.pause_step_name == step
               Kernel.binding.irb # rubocop:disable Lint/Debugger
             end
           else
-            step_orchestrator.execute_step(step)
+            step_orchestrator.execute_step(step, is_last_step: is_last_step)
           end
         end
       end
@@ -63,16 +59,20 @@ module Roast
         when StepTypeResolver::COMMAND_STEP
           # Command steps should also go through interpolation
           execute_string_step(step, options)
+        when StepTypeResolver::AGENT_STEP
+          execute_agent_step(step, options)
         when StepTypeResolver::GLOB_STEP
-          execute_glob_step(step)
+          execute_glob_step(step, options)
         when StepTypeResolver::ITERATION_STEP
-          execute_iteration_step(step)
+          execute_iteration_step(step, options)
         when StepTypeResolver::CONDITIONAL_STEP
-          execute_conditional_step(step)
+          execute_conditional_step(step, options)
         when StepTypeResolver::CASE_STEP
-          execute_case_step(step)
+          execute_case_step(step, options)
+        when StepTypeResolver::INPUT_STEP
+          execute_input_step(step, options)
         when StepTypeResolver::HASH_STEP
-          execute_hash_step(step)
+          execute_hash_step(step, options)
         when StepTypeResolver::PARALLEL_STEP
           # Use factory for parallel steps
           executor = StepExecutorFactory.for(step, workflow_executor)
@@ -117,6 +117,15 @@ module Roast
         )
       end
 
+      def input_executor
+        @input_executor ||= dependencies[:input_executor] || InputExecutor.new(
+          context.workflow,
+          context.context_path,
+          dependencies[:state_manager] || dependencies[:workflow_executor].state_manager,
+          workflow_executor,
+        )
+      end
+
       def step_orchestrator
         dependencies[:step_orchestrator]
       end
@@ -171,11 +180,20 @@ module Roast
         end
       end
 
-      def execute_glob_step(step)
+      def execute_agent_step(step, options = {})
+        # Extract the step name without the ^ prefix
+        step_name = StepTypeResolver.extract_name(step)
+
+        # Load and execute the agent step
+        exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
+        step_orchestrator.execute_step(step_name, exit_on_error:, step_key: options[:step_key], agent_type: :coding_agent)
+      end
+
+      def execute_glob_step(step, options = {})
         Dir.glob(step).join("\n")
       end
 
-      def execute_iteration_step(step)
+      def execute_iteration_step(step, options = {})
         name = step.keys.first
         command = step[name]
 
@@ -188,15 +206,19 @@ module Roast
         end
       end
 
-      def execute_conditional_step(step)
+      def execute_conditional_step(step, options = {})
         conditional_executor.execute_conditional(step)
       end
 
-      def execute_case_step(step)
+      def execute_case_step(step, options = {})
         case_executor.execute_case(step)
       end
 
-      def execute_hash_step(step)
+      def execute_input_step(step, options = {})
+        input_executor.execute_input(step["input"])
+      end
+
+      def execute_hash_step(step, options = {})
         name, command = step.to_a.flatten
         interpolated_name = interpolator.interpolate(name)
 
@@ -208,7 +230,8 @@ module Roast
 
           # Execute the command directly using the appropriate executor
           # Pass the original key name for configuration lookup
-          result = execute(interpolated_command, { exit_on_error: exit_on_error, step_key: interpolated_name })
+          # Merge options to preserve is_last_step
+          result = execute(interpolated_command, { exit_on_error:, step_key: interpolated_name }.merge(options))
           context.workflow.output[interpolated_name] = result
           result
         end
@@ -225,17 +248,18 @@ module Roast
         if StepTypeResolver.command_step?(interpolated_step)
           # Command step - execute directly, preserving any passed options
           exit_on_error = options.fetch(:exit_on_error, true)
-          execute_command_step(interpolated_step, { exit_on_error: exit_on_error })
+          execute_command_step(interpolated_step, { exit_on_error: })
         else
           exit_on_error = options.fetch(:exit_on_error, context.exit_on_error?(step))
-          execute_standard_step(interpolated_step, options.merge(exit_on_error: exit_on_error))
+          execute_standard_step(interpolated_step, options.merge(exit_on_error:))
         end
       end
 
       def execute_standard_step(step, options)
         exit_on_error = options.fetch(:exit_on_error, true)
         step_key = options[:step_key]
-        step_orchestrator.execute_step(step, exit_on_error: exit_on_error, step_key: step_key)
+        is_last_step = options[:is_last_step]
+        step_orchestrator.execute_step(step, exit_on_error:, step_key:, is_last_step:)
       end
 
       def validate_each_step!(step)

data/lib/roast/workflow/step_executor_factory.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executor_registry"
-require "roast/workflow/step_executors/hash_step_executor"
-require "roast/workflow/step_executors/parallel_step_executor"
-require "roast/workflow/step_executors/string_step_executor"
-
 module Roast
   module Workflow
     # Factory for creating step executors - now delegates to registry

data/lib/roast/workflow/step_executor_registry.rb

@@ -43,10 +43,7 @@ module Roast
         def clear!
           @executors.clear
           @type_matchers.clear
-          # Reset the factory's defaults flag if it's defined
-          if defined?(StepExecutorFactory)
-            StepExecutorFactory.instance_variable_set(:@defaults_registered, false)
-          end
+          StepExecutorFactory.instance_variable_set(:@defaults_registered, false)
         end
 
         # Get all registered executors (useful for debugging)

data/lib/roast/workflow/step_executor_with_reporting.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Decorator that adds token consumption reporting to step execution
+    class StepExecutorWithReporting
+      def initialize(base_executor, context, output: $stderr)
+        @base_executor = base_executor
+        @context = context
+        @reporter = StepCompletionReporter.new(output: output)
+        @name_extractor = StepNameExtractor.new
+      end
+
+      def execute(step, options = {})
+        # Track tokens before execution
+        tokens_before = @context.workflow.context_manager&.total_tokens || 0
+
+        # Execute the step
+        result = @base_executor.execute(step, options)
+
+        # Report token consumption after successful execution
+        tokens_after = @context.workflow.context_manager&.total_tokens || 0
+        tokens_consumed = tokens_after - tokens_before
+
+        step_type = StepTypeResolver.resolve(step, @context)
+        step_name = @name_extractor.extract(step, step_type)
+        @reporter.report(step_name, tokens_consumed, tokens_after)
+
+        result
+      end
+
+      # Override execute_steps to ensure reporting happens for each step
+      def execute_steps(workflow_steps)
+        workflow_steps.each_with_index do |step, index|
+          is_last_step = (index == workflow_steps.length - 1)
+          case step
+          when Hash
+            execute(step, is_last_step:)
+          when Array
+            execute(step, is_last_step:)
+          when String
+            execute(step, is_last_step:)
+            # Handle pause after string steps
+            if @context.workflow.pause_step_name == step
+              Kernel.binding.irb # rubocop:disable Lint/Debugger
+            end
+          else
+            # For other types, delegate to base executor
+            execute(step, is_last_step:)
+          end
+        end
+      end
+
+      # Delegate all other methods to the base executor
+      def method_missing(method, *args, **kwargs, &block)
+        if @base_executor.respond_to?(method)
+          @base_executor.send(method, *args, **kwargs, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @base_executor.respond_to?(method, include_private) || super
+      end
+    end
+  end
+end

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executors/base_step_executor"
-require "roast/workflow/step_runner"
-
 module Roast
   module Workflow
     module StepExecutors

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executors/base_step_executor"
-require "roast/workflow/step_runner"
-
 module Roast
   module Workflow
     module StepExecutors

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roast/workflow/step_executors/base_step_executor"
-
 module Roast
   module Workflow
     module StepExecutors

data/lib/roast/workflow/step_factory.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Factory for creating step instances based on step characteristics
+    class StepFactory
+      class << self
+        # Create a step instance based on the step type and characteristics
+        #
+        # @param workflow [BaseWorkflow] The workflow instance
+        # @param step_name [String, StepName] The name of the step
+        # @param options [Hash] Additional options for step creation
+        # @return [BaseStep] The appropriate step instance
+        def create(workflow, step_name, options = {})
+          name = normalize_step_name(step_name)
+
+          # Determine the step class based on characteristics
+          step_class = determine_step_class(name, options)
+
+          # Create the step instance with appropriate parameters
+          build_step_instance(step_class, workflow, name, options)
+        end
+
+        private
+
+        def normalize_step_name(step_name)
+          step_name.is_a?(Roast::ValueObjects::StepName) ? step_name : Roast::ValueObjects::StepName.new(step_name)
+        end
+
+        def determine_step_class(name, options)
+          # Check if this is an agent step (indicated by special processing needs)
+          if options[:agent_type] == :coding_agent
+            Roast::Workflow::AgentStep
+          elsif name.plain_text?
+            # Plain text steps are always prompt steps
+            options[:agent_type] == :coding_agent ? Roast::Workflow::AgentStep : Roast::Workflow::PromptStep
+          else
+            # Default to BaseStep for directory-based steps
+            Roast::Workflow::BaseStep
+          end
+        end
+
+        def build_step_instance(step_class, workflow, name, options)
+          step_params = {
+            name:,
+          }
+
+          # Add context path if provided
+          step_params[:context_path] = options[:context_path] if options[:context_path]
+
+          step_class.new(workflow, **step_params)
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_loader.rb

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
-require "roast/value_objects/step_name"
-require "roast/workflow/workflow_context"
-require "roast/workflow/base_step"
-require "roast/workflow/prompt_step"
-
 module Roast
   module Workflow
     # Handles loading and instantiation of workflow steps
     class StepLoader
-      DEFAULT_MODEL = "openai/gpt-4o-mini"
+      DEFAULT_MODEL = "gpt-4o-mini"
 
       # Custom exception classes
       class StepLoaderError < StandardError
@@ -47,8 +42,9 @@ module Roast
       #
       # @param step_name [String, StepName] The name of the step to load
       # @param step_key [String] The configuration key for the step (optional)
+      # @param options [Hash] Additional options for step loading
       # @return [BaseStep] The loaded step instance
-      def load(step_name, step_key: nil)
+      def load(step_name, step_key: nil, is_last_step: nil, **options)
         name = step_name.is_a?(Roast::ValueObjects::StepName) ? step_name : Roast::ValueObjects::StepName.new(step_name)
 
         # Get step config for per-step path
@@ -57,17 +53,17 @@ module Roast
 
         # First check for a prompt step (contains spaces)
         if name.plain_text?
-          step = Roast::Workflow::PromptStep.new(workflow, name: name.to_s)
+          step = StepFactory.create(workflow, name, options)
           # Use step_key for configuration if provided, otherwise use name
           config_key = step_key || name.to_s
-          configure_step(step, config_key)
+          configure_step(step, config_key, is_last_step:)
           return step
         end
 
         # Look for Ruby file in various locations
         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)
+          return load_ruby_step(step_file_path, name.to_s, is_last_step:)
         end
 
         # Look for step directory
@@ -76,7 +72,10 @@ module Roast
           raise StepNotFoundError.new("Step directory or file not found: #{name}", step_name: name.to_s)
         end
 
-        create_step_instance(Roast::Workflow::BaseStep, name.to_s, step_directory)
+        # Use factory to create the appropriate step instance
+        step = StepFactory.create(workflow, name, options.merge(context_path: step_directory))
+        configure_step(step, name.to_s, is_last_step:)
+        step
       end
 
       private
@@ -141,7 +140,7 @@ module Roast
       end
 
       # Load a Ruby step from a file
-      def load_ruby_step(file_path, step_name)
+      def load_ruby_step(file_path, step_name, is_last_step: nil)
         $stderr.puts "Requiring step file: #{file_path}"
 
         begin
@@ -154,18 +153,24 @@ module Roast
 
         step_class = step_name.classify.constantize
         context = File.dirname(file_path)
-        create_step_instance(step_class, step_name, context)
+        # For Ruby steps, we instantiate the specific class directly
+        # Convert step_name to StepName value object
+        step_name_obj = Roast::ValueObjects::StepName.new(step_name)
+        step = step_class.new(workflow, name: step_name_obj, context_path: context)
+        configure_step(step, step_name, is_last_step:)
+        step
       end
 
       # Create and configure a step instance
-      def create_step_instance(step_class, step_name, context_path)
-        step = step_class.new(workflow, name: step_name, context_path: context_path)
-        configure_step(step, step_name)
+      def create_step_instance(step_class, step_name, context_path, options = {})
+        is_last_step = options[:is_last_step]
+        step = StepFactory.create(workflow, step_name, options.merge(context_path: context_path))
+        configure_step(step, step_name, is_last_step:)
         step
       end
 
       # Configure a step instance with settings from config_hash
-      def configure_step(step, step_name)
+      def configure_step(step, step_name, is_last_step: nil)
         step_config = config_hash[step_name]
 
         # Always set the model
@@ -176,6 +181,11 @@ module Roast
 
         # Apply additional configuration if present
         apply_step_configuration(step, step_config) if step_config.present?
+
+        # Set print_response to true for the last step if not already configured
+        if is_last_step && !step_config&.key?("print_response")
+          step.print_response = true
+        end
       end
 
       # Determine which model to use for the step
@@ -189,6 +199,10 @@ module Roast
         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")
+
+        if step_config.key?("available_tools")
+          step.available_tools = step_config["available_tools"]
+        end
       end
     end
   end

data/lib/roast/workflow/step_name_extractor.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Roast
+  module Workflow
+    # Extracts human-readable names from various step types
+    class StepNameExtractor
+      def extract(step, step_type)
+        case step_type
+        when StepTypeResolver::COMMAND_STEP
+          extract_command_name(step)
+        when StepTypeResolver::HASH_STEP
+          extract_hash_step_name(step)
+        when StepTypeResolver::ITERATION_STEP
+          extract_iteration_step_name(step)
+        when StepTypeResolver::CONDITIONAL_STEP
+          extract_conditional_step_name(step)
+        when StepTypeResolver::CASE_STEP
+          "case"
+        when StepTypeResolver::INPUT_STEP
+          "input"
+        when StepTypeResolver::AGENT_STEP
+          StepTypeResolver.extract_name(step)
+        when StepTypeResolver::STRING_STEP
+          step.to_s
+        else
+          step.to_s
+        end
+      end
+
+      private
+
+      def extract_command_name(step)
+        cmd = step.to_s.strip
+        cmd.length > 20 ? "#{cmd[0..19]}..." : cmd
+      end
+
+      def extract_hash_step_name(step)
+        key, value = step.to_a.first
+
+        # Check if this looks like an inline prompt (key is similar to sanitized value)
+        if value.is_a?(String)
+          # Get first non-empty line
+          first_line = value.lines.map(&:strip).find { |line| !line.empty? } || ""
+
+          # If key looks like it was auto-generated from the content, use truncated content
+          sanitized = first_line.downcase.gsub(/[^a-z0-9_]/, "_").squeeze("_").gsub(/^_|_$/, "")
+          if key.to_s == sanitized || key.to_s.start_with?(sanitized[0..15])
+            # This is likely an inline prompt
+            first_line.length > 20 ? "#{first_line[0..19]}..." : first_line
+          else
+            # This is a labeled step
+            key.to_s
+          end
+        else
+          key.to_s
+        end
+      end
+
+      def extract_iteration_step_name(step)
+        if step.key?("each")
+          items = step["each"]
+          count = items.respond_to?(:size) ? items.size : "?"
+          "each (#{count} items)"
+        elsif step.key?("repeat")
+          config = step["repeat"]
+          times = config.is_a?(Hash) ? config["times"] || "?" : config
+          "repeat (#{times} times)"
+        else
+          "iteration"
+        end
+      end
+
+      def extract_conditional_step_name(step)
+        if step.key?("if")
+          "if"
+        elsif step.key?("unless")
+          "unless"
+        else
+          "conditional"
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/step_orchestrator.rb

@@ -22,7 +22,7 @@ module Roast
         @workflow_executor = workflow_executor
       end
 
-      def execute_step(name, exit_on_error: true, step_key: nil)
+      def execute_step(name, exit_on_error: true, step_key: nil, **options)
         resource_type = @workflow.respond_to?(:resource) ? @workflow.resource&.type : nil
 
         @error_handler.with_error_handling(name, resource_type: resource_type) do
@@ -30,7 +30,8 @@ module Roast
 
           # 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)
+          is_last_step = options[:is_last_step]
+          step_object = @step_loader.load(name, step_key: load_key, is_last_step:, **options)
           step_result = step_object.call
 
           # Store result in workflow output