roast-ai 0.1.0 → 0.1.1

data/lib/roast/workflow/base_step.rb

@@ -8,35 +8,34 @@ module Roast
     class BaseStep
       extend Forwardable
 
-      attr_accessor :model, :print_response, :loop, :json, :params
+      attr_accessor :model, :print_response, :auto_loop, :json, :params, :resource
       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-3-7-sonnet", name: nil, context_path: nil)
+      def initialize(workflow, model: "anthropic:claude-3-7-sonnet", name: nil, context_path: nil, auto_loop: true)
         @workflow = workflow
         @model = model
         @name = name || self.class.name.underscore.split("/").last
         @context_path = context_path || determine_context_path
         @print_response = false
-        @loop = true
+        @auto_loop = auto_loop
         @json = false
         @params = {}
+        @resource = workflow.resource if workflow.respond_to?(:resource)
       end
 
       def call
         prompt(read_sidecar_prompt)
-        chat_completion(print_response:, loop:, json:, params:)
+        chat_completion(print_response:, auto_loop:, json:, params:)
       end
 
       protected
 
-      def chat_completion(print_response: false, loop: true, json: false, params: {})
-        workflow.chat_completion(openai: model, loop:, json:, params:).tap do |response|
-          append_to_final_output(response) if print_response
-        end.then do |response|
+      def chat_completion(print_response: false, auto_loop: true, json: false, params: {})
+        workflow.chat_completion(openai: model, loop: auto_loop, json:, params:).then do |response|
           case response
           in Array
             response.map(&:presence).compact.join("\n")
@@ -44,7 +43,7 @@ module Roast
             response
           end
         end.tap do |response|
-          process_sidecar_output(response)
+          process_output(response, print_response:)
         end
       end
 
@@ -74,19 +73,24 @@ module Roast
       end
 
       def read_sidecar_prompt
-        Roast::Helpers::PromptLoader.load_prompt(self, workflow.file)
+        # For file resources, use the target path for prompt selection
+        # For other resource types, fall back to workflow.file
+        target_path = if resource&.type == :file
+          resource.target
+        else
+          workflow.file
+        end
+
+        Roast::Helpers::PromptLoader.load_prompt(self, target_path)
       end
 
-      def process_sidecar_output(response)
-        # look for a file named output.txt.erb in the context path
-        # if found, render it with the response
-        # if not found, just return the response
-        # TODO: this can be a lot more sophisticated
-        # incorporating different file types, etc.
+      def process_output(response, print_response:)
         output_path = File.join(context_path, "output.txt")
-        if File.exist?(output_path)
+        if File.exist?(output_path) && print_response
           # TODO: use the workflow binding or the step?
           append_to_final_output(ERB.new(File.read(output_path), trim_mode: "-").result(binding))
+        elsif print_response
+          append_to_final_output(response)
         end
       end
     end

data/lib/roast/workflow/base_workflow.rb

@@ -2,6 +2,9 @@
 
 require "raix/chat_completion"
 require "raix/function_dispatch"
+require "active_support"
+require "active_support/isolated_execution_state"
+require "active_support/notifications"
 
 module Roast
   module Workflow
@@ -11,23 +14,26 @@ module Roast
       attr_accessor :file,
         :concise,
         :output_file,
-        :subject_file,
         :verbose,
         :name,
         :context_path,
-        :output
+        :output,
+        :resource,
+        :session_name,
+        :session_timestamp,
+        :configuration
 
-      def initialize(file, subject_file = nil, name: nil, context_path: nil)
+      def initialize(file = nil, name: nil, context_path: nil, resource: nil, session_name: nil, configuration: nil)
         @file = file
-        @subject_file = subject_file
         @name = name || self.class.name.underscore.split("/").last
         @context_path = context_path || determine_context_path
         @final_output = []
         @output = {}
+        @resource = resource || Roast::Resources.for(file)
+        @session_name = session_name || @name
+        @session_timestamp = nil
+        @configuration = configuration
         transcript << { system: read_sidecar_prompt }
-        unless subject_file.blank?
-          transcript << { user: read_subject_file }
-        end
         Roast::Tools.setup_interrupt_handler(transcript)
         Roast::Tools.setup_exit_handler(self)
       end
@@ -37,7 +43,42 @@ module Roast
       end
 
       def final_output
-        @final_output.join("\n")
+        @final_output.join("\n\n")
+      end
+
+      # Override chat_completion to add instrumentation
+      def chat_completion(**kwargs)
+        start_time = Time.now
+        model = kwargs[:openai] || "default"
+
+        ActiveSupport::Notifications.instrument("roast.chat_completion.start", {
+          model: model,
+          parameters: kwargs.except(:openai),
+        })
+
+        result = super(**kwargs)
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.chat_completion.complete", {
+          success: true,
+          model: model,
+          parameters: kwargs.except(:openai),
+          execution_time: execution_time,
+          response_size: result.to_s.length,
+        })
+
+        result
+      rescue => e
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.chat_completion.error", {
+          error: e.class.name,
+          message: e.message,
+          model: model,
+          parameters: kwargs.except(:openai),
+          execution_time: execution_time,
+        })
+        raise
       end
 
       private
@@ -66,14 +107,6 @@ module Roast
       def read_sidecar_prompt
         Roast::Helpers::PromptLoader.load_prompt(self, file)
       end
-
-      def read_subject_file
-        [
-          "# SUT (Subject Under Test)",
-          "# #{subject_file}",
-          File.read(subject_file),
-        ].join("\n")
-      end
     end
   end
 end

data/lib/roast/workflow/configuration.rb

@@ -8,7 +8,7 @@ module Roast
     # 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
+      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :api_token, :model, :resource
       attr_accessor :target
 
       def initialize(workflow_path, options = {})
@@ -30,6 +30,23 @@ module Roast
 
         # Process the target command if it's a shell command
         @target = process_target(@target) if has_target?
+
+        # 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
+
+        # Process API token if provided
+        if @config_hash["api_token"]
+          @api_token = process_shell_command(@config_hash["api_token"])
+        end
+
+        # Extract default model if provided
+        @model = @config_hash["model"]
       end
 
       def context_path
@@ -48,8 +65,49 @@ module Roast
         @config_hash[step_name] || {}
       end
 
-      def find_step_index(steps, target_step)
-        steps.each_with_index do |step, index|
+      # Find the index of a step in the workflow steps array
+      # @param [Array] steps Optional - The steps array to search (defaults to self.steps)
+      # @param [String] target_step The name of the step to find
+      # @return [Integer, nil] The index of the step, or nil if not found
+      def find_step_index(steps_array = nil, target_step = nil)
+        # 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
+        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
@@ -58,6 +116,7 @@ module Roast
             return index
           end
         end
+
         nil
       end
 
@@ -81,8 +140,8 @@ module Roast
 
       private
 
-      def process_target(command)
-        # If it's a bash command with the new $(command) syntax
+      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
@@ -92,13 +151,29 @@ module Roast
           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 command.include?("*")
-          return Dir.glob(command).map { |file| File.expand_path(file) }.join("\n")
+        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?("/")
+
         # assumed to be a direct file path(s)
-        File.expand_path(command)
+        File.expand_path(processed)
       end
 
       def extract_step_name(step)

data/lib/roast/workflow/configuration_parser.rb

@@ -3,6 +3,9 @@
 require_relative "workflow_executor"
 require_relative "configuration"
 require_relative "../helpers/function_caching_interceptor"
+require "active_support"
+require "active_support/isolated_execution_state"
+require "active_support/notifications"
 
 module Roast
   module Workflow
@@ -17,10 +20,14 @@ module Roast
         @configuration = Configuration.new(workflow_path, options)
         @options = options
         @files = files
+        @replay_processed = false # Initialize replay tracking
         include_tools
+        load_roast_initializers
+        configure_api_client
       end
 
       def begin!
+        start_time = Time.now
         $stderr.puts "Starting workflow..."
         $stderr.puts "Workflow: #{configuration.workflow_path}"
         $stderr.puts "Options: #{options}"
@@ -28,6 +35,12 @@ module Roast
         name = configuration.basename
         context_path = configuration.context_path
 
+        ActiveSupport::Notifications.instrument("roast.workflow.start", {
+          workflow_path: configuration.workflow_path,
+          options: options,
+          name: name,
+        })
+
         if files.any?
           $stderr.puts "WARNING: Ignoring target parameter because files were provided: #{configuration.target}" if configuration.has_target?
           files.each do |file|
@@ -42,17 +55,37 @@ module Roast
             parse(configuration.steps)
           end
         else
-          $stdout.puts "🚫 ERROR: No files or target provided! 🚫"
+          # Handle targetless workflow - run once without a specific target
+          $stderr.puts "Running targetless workflow"
+          setup_workflow(nil, name:, context_path:)
+          parse(configuration.steps)
         end
+      ensure
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.workflow.complete", {
+          workflow_path: configuration.workflow_path,
+          success: !$ERROR_INFO,
+          execution_time: execution_time,
+        })
       end
 
       private
 
       def setup_workflow(file, name:, context_path:)
-        @current_workflow = BaseWorkflow.new(file, name:, context_path:).tap do |workflow|
+        session_name = configuration.name
+
+        @current_workflow = BaseWorkflow.new(
+          file,
+          name: name,
+          context_path: context_path,
+          resource: configuration.resource,
+          session_name: session_name,
+          configuration: configuration,
+        ).tap do |workflow|
           workflow.output_file = options[:output] if options[:output].present?
-          workflow.subject_file = options[:subject] if options[:subject].present?
           workflow.verbose = options[:verbose] if options[:verbose].present?
+          workflow.concise = options[:concise] if options[:concise].present?
         end
       end
 
@@ -64,15 +97,108 @@ module Roast
         BaseWorkflow.include(*configuration.tools.map(&:constantize))
       end
 
+      def load_roast_initializers
+        # Project-specific initializers
+        project_initializers = File.join(Dir.pwd, ".roast", "initializers")
+
+        if Dir.exist?(project_initializers)
+          $stderr.puts "Loading project initializers from #{project_initializers}"
+          Dir.glob(File.join(project_initializers, "**/*.rb")).sort.each do |file|
+            $stderr.puts "Loading initializer: #{file}"
+            require file
+          end
+        end
+      rescue => e
+        Roast::Helpers::Logger.error("Error loading initializers: #{e.message}")
+        # Don't fail the workflow if initializers can't be loaded
+      end
+
+      def configure_api_client
+        return unless configuration.api_token
+
+        begin
+          require "raix"
+
+          # Configure OpenAI client with the token
+          $stderr.puts "Configuring API client with token from workflow"
+
+          # Initialize the OpenAI client if it doesn't exist
+          if defined?(Raix.configuration.openai_client)
+            # Create a new client with the token
+            Raix.configuration.openai_client = OpenAI::Client.new(access_token: configuration.api_token)
+          else
+            require "openai"
+
+            Raix.configure do |config|
+              config.openai_client = OpenAI::Client.new(access_token: configuration.api_token)
+            end
+          end
+        rescue => e
+          Roast::Helpers::Logger.error("Error configuring API client: #{e.message}")
+          # Don't fail the workflow if client can't be configured
+        end
+      end
+
+      def load_state_and_update_steps(steps, skip_until, step_name, timestamp)
+        state_repository = FileStateRepository.new
+
+        if timestamp
+          if state_repository.load_state_before_step(current_workflow, step_name, timestamp: timestamp)
+            $stderr.puts "Loaded saved state for step #{step_name} in session #{timestamp}"
+          else
+            $stderr.puts "Could not find saved state for step #{step_name} in session #{timestamp}, running from requested step"
+          end
+        elsif state_repository.load_state_before_step(current_workflow, step_name)
+          $stderr.puts "Loaded saved state for step #{step_name}"
+        else
+          $stderr.puts "Could not find saved state for step #{step_name}, running from requested step"
+        end
+
+        # Always return steps from the requested index, regardless of state loading success
+        steps[skip_until..-1]
+      end
+
       def parse(steps)
         return run(steps) if steps.is_a?(String)
 
+        # Handle replay option - skip to the specified step
+        if @options[:replay] && !@replay_processed
+          replay_param = @options[:replay]
+          timestamp = nil
+          step_name = replay_param
+
+          # Check if timestamp is prepended (format: timestamp:step_name)
+          if replay_param.include?(":")
+            timestamp, step_name = replay_param.split(":", 2)
+
+            # Validate timestamp format (YYYYMMDD_HHMMSS_LLL)
+            unless timestamp.match?(/^\d{8}_\d{6}_\d{3}$/)
+              raise ArgumentError, "Invalid timestamp format: #{timestamp}. Expected YYYYMMDD_HHMMSS_LLL"
+            end
+          end
+
+          # Find step index by iterating through the steps
+          skip_until = find_step_index_in_array(steps, step_name)
+
+          if skip_until
+            $stderr.puts "Replaying from step: #{step_name}#{timestamp ? " (session: #{timestamp})" : ""}"
+            current_workflow.session_timestamp = timestamp if timestamp
+            steps = load_state_and_update_steps(steps, skip_until, step_name, timestamp)
+          else
+            $stderr.puts "Step #{step_name} not found in workflow, running from beginning"
+          end
+          @replay_processed = true # Mark that we've processed replay, so we don't do it again in recursive calls
+        end
+
         # Use the WorkflowExecutor to execute the steps
         executor = WorkflowExecutor.new(current_workflow, configuration.config_hash, configuration.context_path)
         executor.execute_steps(steps)
 
         $stderr.puts "🔥🔥🔥 ROAST COMPLETE! 🔥🔥🔥"
 
+        # Save the final output to the session directory
+        save_final_output(current_workflow)
+
         # Save results to file if specified
         if current_workflow.output_file
           File.write(current_workflow.output_file, current_workflow.final_output)
@@ -87,6 +213,48 @@ module Roast
         executor = WorkflowExecutor.new(current_workflow, configuration.config_hash, configuration.context_path)
         executor.execute_step(name)
       end
+
+      def find_step_index_in_array(steps_array, step_name)
+        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 == step_name
+          when Array
+            # This is a parallel step container, search inside it
+            step.each_with_index do |substep, _substep_index|
+              case substep
+              when Hash
+                # Could be {name: command}
+                substep_key = substep.keys.first
+                return index if substep_key == step_name
+              when String
+                return index if substep == step_name
+              end
+            end
+          when String
+            return index if step == step_name
+          end
+        end
+        nil
+      end
+
+      def save_final_output(workflow)
+        return unless workflow.respond_to?(:session_name) && workflow.session_name && workflow.respond_to?(:final_output)
+
+        begin
+          final_output = workflow.final_output.to_s
+          return if final_output.empty?
+
+          state_repository = FileStateRepository.new
+          output_file = state_repository.save_final_output(workflow, final_output)
+          $stderr.puts "Final output saved to: #{output_file}" if output_file
+        rescue => e
+          # Don't fail if saving output fails
+          $stderr.puts "Warning: Failed to save final output to session: #{e.message}"
+        end
+      end
     end
   end
 end

data/lib/roast/workflow/file_state_repository.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "session_manager"
+require_relative "state_repository"
+
+module Roast
+  module Workflow
+    # File-based implementation of StateRepository
+    # Handles state persistence to the filesystem in a thread-safe manner
+    class FileStateRepository < StateRepository
+      def initialize(session_manager = SessionManager.new)
+        super()
+        @state_mutex = Mutex.new
+        @session_manager = session_manager
+      end
+
+      def save_state(workflow, step_name, state_data)
+        @state_mutex.synchronize do
+          # If workflow doesn't have a timestamp, let the session manager create one
+          workflow.session_timestamp ||= @session_manager.create_new_session(workflow.object_id)
+
+          session_dir = @session_manager.ensure_session_directory(
+            workflow.object_id,
+            workflow.session_name,
+            workflow.file,
+            timestamp: workflow.session_timestamp,
+          )
+          step_file = File.join(session_dir, format_step_filename(state_data[:order], step_name))
+          File.write(step_file, JSON.pretty_generate(state_data))
+        end
+      rescue => e
+        $stderr.puts "Failed to save state for step #{step_name}: #{e.message}"
+      end
+
+      def load_state_before_step(workflow, step_name, timestamp: nil)
+        session_dir = @session_manager.find_session_directory(workflow.session_name, workflow.file, timestamp)
+        return false unless session_dir
+
+        step_files = find_step_files(session_dir)
+        target_index = find_step_before(step_files, step_name)
+        return false if target_index.nil? || target_index < 0
+
+        state_data = load_state_file(step_files[target_index])
+
+        # If no timestamp provided and workflow has no session, copy states to new session
+        should_copy = !timestamp && workflow.session_timestamp.nil?
+
+        copy_states_to_new_session(workflow, session_dir, step_files[0..target_index]) if should_copy
+        state_data
+      end
+
+      def save_final_output(workflow, output_content)
+        return if output_content.empty?
+
+        session_dir = @session_manager.ensure_session_directory(
+          workflow.object_id,
+          workflow.session_name,
+          workflow.file,
+          timestamp: workflow.session_timestamp,
+        )
+        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}"
+        nil
+      end
+
+      private
+
+      def find_step_files(session_dir)
+        Dir.glob(File.join(session_dir, "step_*_*.json")).sort_by do |file|
+          file[/step_(\d+)_/, 1].to_i
+        end
+      end
+
+      def find_step_before(step_files, target_step_name)
+        step_files.each_with_index do |file, index|
+          if file.end_with?("_#{target_step_name}.json")
+            return index - 1
+          end
+        end
+        nil
+      end
+
+      def load_state_file(state_file)
+        JSON.parse(File.read(state_file), symbolize_names: true)
+      end
+
+      def copy_states_to_new_session(workflow, source_session_dir, state_files)
+        # Create a new session for the workflow
+        new_timestamp = @session_manager.create_new_session(workflow.object_id)
+        workflow.session_timestamp = new_timestamp
+
+        # Get the new session directory path
+        current_session_dir = @session_manager.ensure_session_directory(
+          workflow.object_id,
+          workflow.session_name,
+          workflow.file,
+          timestamp: workflow.session_timestamp,
+        )
+
+        # Skip copying if the source and destination are the same
+        return if source_session_dir == current_session_dir
+
+        # Make sure the new directory actually exists before copying
+        FileUtils.mkdir_p(current_session_dir) unless File.directory?(current_session_dir)
+
+        # Copy each state file to the new session directory
+        state_files.each do |state_file|
+          FileUtils.cp(state_file, current_session_dir)
+        end
+
+        # Return success
+        true
+      end
+
+      def format_step_filename(order, step_name)
+        "step_#{order.to_s.rjust(3, "0")}_#{step_name}.json"
+      end
+    end
+  end
+end