roast-ai 0.1.0 → 0.1.2

data/lib/roast/resources.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "resources/base_resource"
+require_relative "resources/file_resource"
+require_relative "resources/directory_resource"
+require_relative "resources/url_resource"
+require_relative "resources/api_resource"
+require_relative "resources/none_resource"
+require "uri"
+
+module Roast
+  # The Resources module contains classes for handling different types of resources
+  # that workflows can operate on. Each resource type implements a common interface.
+  module Resources
+    extend self
+
+    # Create the appropriate resource based on the target
+    # @param target [String] The target specified in the workflow
+    # @return [BaseResource] A resource object of the appropriate type
+    def for(target)
+      type = detect_type(target)
+
+      case type
+      when :file
+        FileResource.new(target)
+      when :directory
+        DirectoryResource.new(target)
+      when :url
+        UrlResource.new(target)
+      when :api
+        ApiResource.new(target)
+      when :command
+        CommandResource.new(target)
+      when :none
+        NoneResource.new(target)
+      else
+        BaseResource.new(target) # Default to base resource
+      end
+    end
+
+    # Determines the resource type from the target
+    # @param target [String] The target specified in the workflow
+    # @return [Symbol] :file, :directory, :url, :api, or :none
+    def detect_type(target)
+      return :none if target.nil? || target.strip.empty?
+
+      # Check for command syntax $(...)
+      if target.match?(/^\$\(.*\)$/)
+        return :command
+      end
+
+      # Check for URLs
+      if target.start_with?("http://", "https://", "ftp://")
+        return :url
+      end
+
+      # Try to parse as URI to detect other URL schemes
+      begin
+        uri = URI.parse(target)
+        return :url if uri.scheme && uri.host
+      rescue URI::InvalidURIError
+        # Not a URL, continue with other checks
+      end
+
+      # Check for directory
+      if Dir.exist?(target)
+        return :directory
+      end
+
+      # Check for glob patterns (containing * or ?)
+      if target.include?("*") || target.include?("?")
+        matches = Dir.glob(target)
+        return :none if matches.empty?
+        # If the glob matches only directories, treat as directory type
+        return :directory if matches.all? { |path| Dir.exist?(path) }
+
+        # Otherwise treat as file type (could be mixed or all files)
+        return :file
+      end
+
+      # Check for file
+      if File.exist?(target)
+        return :file
+      end
+
+      # Check for API configuration in Fetch API style format
+      begin
+        potential_config = JSON.parse(target)
+        if potential_config.is_a?(Hash) && potential_config.key?("url") && potential_config.key?("options")
+          return :api
+        end
+      rescue JSON::ParserError
+        # Not a JSON string, continue with other checks
+      end
+
+      # Default to file for anything else
+      :file
+    end
+  end
+end

data/lib/roast/tools/coding_agent.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+require "open3"
+require "tempfile"
+require "securerandom"
+
+module Roast
+  module Tools
+    module CodingAgent
+      extend self
+
+      class << self
+        def included(base)
+          base.class_eval do
+            function(
+              :coding_agent,
+              "AI-powered coding agent that runs Claude Code CLI with the given prompt",
+              prompt: { type: "string", description: "The prompt to send to Claude Code" },
+            ) do |params|
+              Roast::Tools::CodingAgent.call(params[:prompt])
+            end
+          end
+        end
+      end
+
+      def call(prompt)
+        Roast::Helpers::Logger.info("🤖 Running CodingAgent\n")
+        run_claude_code(prompt)
+      rescue StandardError => e
+        "Error running CodingAgent: #{e.message}".tap do |error_message|
+          Roast::Helpers::Logger.error(error_message + "\n")
+          Roast::Helpers::Logger.debug(e.backtrace.join("\n") + "\n") if ENV["DEBUG"]
+        end
+      end
+
+      private
+
+      def run_claude_code(prompt)
+        Roast::Helpers::Logger.debug("🤖 Executing Claude Code CLI with prompt: #{prompt}\n")
+
+        # Create a temporary file with a unique name
+        timestamp = Time.now.to_i
+        random_id = SecureRandom.hex(8)
+        pid = Process.pid
+        temp_file = Tempfile.new(["claude_prompt_#{timestamp}_#{pid}_#{random_id}", ".txt"])
+
+        begin
+          # Write the prompt to the file
+          temp_file.write(prompt)
+          temp_file.close
+
+          # Run Claude Code CLI using the temp file as input
+          claude_code_command = ENV.fetch("CLAUDE_CODE_COMMAND", "claude -p")
+          stdout, stderr, status = Open3.capture3("cat #{temp_file.path} | #{claude_code_command}")
+
+          if status.success?
+            stdout
+          else
+            "Error running ClaudeCode: #{stderr}"
+          end
+        ensure
+          # Always clean up the temp file
+          temp_file.unlink
+        end
+      end
+    end
+  end
+end

data/lib/roast/tools.rb

@@ -8,6 +8,7 @@ require "roast/tools/read_file"
 require "roast/tools/search_file"
 require "roast/tools/write_file"
 require "roast/tools/cmd"
+require "roast/tools/coding_agent"
 
 module Roast
   module Tools

data/lib/roast/version.rb

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

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,42 +2,102 @@
 
 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"
 
 module Roast
   module Workflow
     class BaseWorkflow
       include Raix::ChatCompletion
 
+      attr_reader :output
       attr_accessor :file,
         :concise,
         :output_file,
-        :subject_file,
         :verbose,
         :name,
         :context_path,
-        :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 = {}
+        @output = ActiveSupport::HashWithIndifferentAccess.new
+        @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
 
+      # Custom writer for output to ensure it's always a HashWithIndifferentAccess
+      def output=(value)
+        @output = if value.is_a?(ActiveSupport::HashWithIndifferentAccess)
+          value
+        else
+          ActiveSupport::HashWithIndifferentAccess.new(value)
+        end
+      end
+
       def append_to_final_output(message)
         @final_output << message
       end
 
       def final_output
-        @final_output.join("\n")
+        return @final_output if @final_output.is_a?(String)
+        return "" if @final_output.nil?
+
+        # Handle array case (expected normal case)
+        if @final_output.respond_to?(:join)
+          @final_output.join("\n\n")
+        else
+          # Handle any other unexpected type by converting to string
+          @final_output.to_s
+        end
+      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 +126,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)