roast-ai 0.1.0

data/lib/roast/tools/search_file.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "roast/helpers/logger"
+
+module Roast
+  module Tools
+    module SearchFile
+      extend self
+
+      class << self
+        # Add this method to be included in other classes
+        def included(base)
+          base.class_eval do
+            function(
+              :search_for_file,
+              'Search for a file in the project using `find . -type f -path "*#{@file_name}*"` in the project root',
+              name: { type: "string", description: "filename with as much of the path as you can deduce" },
+            ) do |params|
+              Roast::Tools::SearchFile.call(params[:name]).tap do |result|
+                Roast::Helpers::Logger.debug(result) if ENV["DEBUG"]
+              end
+            end
+          end
+        end
+      end
+
+      def call(filename)
+        Roast::Helpers::Logger.info("🔍 Searching for file: #{filename}\n")
+        search_for(filename).then do |results|
+          return "No results found for #{filename}" if results.empty?
+          return Roast::Tools::ReadFile.call(results.first) if results.size == 1
+
+          results.inspect # purposely give the AI list of actual paths so that it can read without searching first
+        end
+      rescue StandardError => e
+        "Error searching for file: #{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
+
+      def search_for(filename)
+        # Execute find command and get the output using -path to match against full paths
+        result = %x(find . -type f -path "*#{filename}*").strip
+
+        # Split by newlines and get the first result
+        result.split("\n").map(&:strip).reject(&:empty?).map { |path| path.sub(%r{^\./}, "") }
+      end
+    end
+  end
+end

data/lib/roast/tools/write_file.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "roast/helpers/logger"
+
+module Roast
+  module Tools
+    module WriteFile
+      extend self
+
+      class << self
+        # Add this method to be included in other classes
+        def included(base)
+          base.class_eval do
+            function(
+              :write_file,
+              "Write content to a file. Creates the file if it does not exist, or overwrites it if it does.",
+              path: {
+                type: "string",
+                description: "The path to the file to write, relative to the current working directory: #{Dir.pwd}",
+              },
+              content: { type: "string", description: "The content to write to the file" },
+            ) do |params|
+              Roast::Tools::WriteFile.call(params[:path], params[:content]).tap do |_result|
+                Roast::Helpers::Logger.info(params[:content])
+              end
+            end
+          end
+        end
+      end
+
+      def call(path, content)
+        if path.start_with?("test/")
+
+          Roast::Helpers::Logger.info("📝 Writing to file: #{path}\n")
+
+          # Ensure the directory exists
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+          # Write the content to the file
+          # Check if path is absolute or relative
+          absolute_path = path.start_with?("/") ? path : File.join(Dir.pwd, path)
+
+          File.write(absolute_path, content)
+
+          "Successfully wrote #{content.lines.count} lines to #{path}"
+        else
+          Roast::Helpers::Logger.error("😳 Path must start with 'test/' to use the write_file tool\n")
+          "Error: Path must start with 'test/' to use the write_file tool, try again."
+        end
+      rescue StandardError => e
+        "Error writing file: #{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
+    end
+  end
+end

data/lib/roast/tools.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_support/cache"
+require "English"
+
+require "roast/tools/grep"
+require "roast/tools/read_file"
+require "roast/tools/search_file"
+require "roast/tools/write_file"
+require "roast/tools/cmd"
+
+module Roast
+  module Tools
+    extend self
+
+    CACHE = ActiveSupport::Cache::FileStore.new(File.join(Dir.pwd, ".roast", "cache"))
+
+    def file_to_prompt(file)
+      <<~PROMPT
+        # #{file}
+
+        #{File.read(file)}
+      PROMPT
+    rescue StandardError => e
+      Roast::Helpers::Logger.error("In current directory: #{Dir.pwd}\n")
+      Roast::Helpers::Logger.error("Error reading file #{file}\n")
+
+      raise e # unable to continue without required file
+    end
+
+    def setup_interrupt_handler(object_to_inspect)
+      Signal.trap("INT") do
+        puts "\n\nCaught CTRL-C! Printing before exiting:\n"
+        puts JSON.pretty_generate(object_to_inspect)
+        exit(1)
+      end
+    end
+
+    def setup_exit_handler(context)
+      # Hook that runs on any exit (including crashes and unhandled exceptions)
+      at_exit do
+        if $ERROR_INFO && !$ERROR_INFO.is_a?(SystemExit) # If exiting due to unhandled exception
+          puts "\n\nExiting due to error: #{$ERROR_INFO.class}: #{$ERROR_INFO.message}\n"
+          # Temporary disable the debugger to fix directory issues
+          # context.instance_eval { binding.irb }
+        end
+      end
+    end
+  end
+end

data/lib/roast/version.rb

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

data/lib/roast/workflow/base_step.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "erb"
+require "forwardable"
+
+module Roast
+  module Workflow
+    class BaseStep
+      extend Forwardable
+
+      attr_accessor :model, :print_response, :loop, :json, :params
+      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)
+        @workflow = workflow
+        @model = model
+        @name = name || self.class.name.underscore.split("/").last
+        @context_path = context_path || determine_context_path
+        @print_response = false
+        @loop = true
+        @json = false
+        @params = {}
+      end
+
+      def call
+        prompt(read_sidecar_prompt)
+        chat_completion(print_response:, 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|
+          case response
+          in Array
+            response.map(&:presence).compact.join("\n")
+          else
+            response
+          end
+        end.tap do |response|
+          process_sidecar_output(response)
+        end
+      end
+
+      # Determine the directory where the actual class is defined, not BaseWorkflow
+      def determine_context_path
+        # Get the actual class's source file
+        klass = self.class
+
+        # Try to get the file path where the class is defined
+        path = if klass.name.include?("::")
+          # For namespaced classes like Roast::Workflow::Grading::Workflow
+          # Convert the class name to a relative path
+          class_path = klass.name.underscore + ".rb"
+          # Look through load path to find the actual file
+          $LOAD_PATH.map { |p| File.join(p, class_path) }.find { |f| File.exist?(f) }
+        else
+          # Fall back to the current file if we can't find it
+          __FILE__
+        end
+
+        # Return directory containing the class definition
+        File.dirname(path || __FILE__)
+      end
+
+      def prompt(text)
+        transcript << { user: text }
+      end
+
+      def read_sidecar_prompt
+        Roast::Helpers::PromptLoader.load_prompt(self, workflow.file)
+      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.
+        output_path = File.join(context_path, "output.txt")
+        if File.exist?(output_path)
+          # TODO: use the workflow binding or the step?
+          append_to_final_output(ERB.new(File.read(output_path), trim_mode: "-").result(binding))
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/base_workflow.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "raix/chat_completion"
+require "raix/function_dispatch"
+
+module Roast
+  module Workflow
+    class BaseWorkflow
+      include Raix::ChatCompletion
+
+      attr_accessor :file,
+        :concise,
+        :output_file,
+        :subject_file,
+        :verbose,
+        :name,
+        :context_path,
+        :output
+
+      def initialize(file, subject_file = nil, name: nil, context_path: 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 = {}
+        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
+
+      def append_to_final_output(message)
+        @final_output << message
+      end
+
+      def final_output
+        @final_output.join("\n")
+      end
+
+      private
+
+      # Determine the directory where the actual class is defined, not BaseWorkflow
+      def determine_context_path
+        # Get the actual class's source file
+        klass = self.class
+
+        # Try to get the file path where the class is defined
+        path = if klass.name.include?("::")
+          # For namespaced classes like Roast::Workflow::Grading::Workflow
+          # Convert the class name to a relative path
+          class_path = klass.name.underscore + ".rb"
+          # Look through load path to find the actual file
+          $LOAD_PATH.map { |p| File.join(p, class_path) }.find { |f| File.exist?(f) }
+        else
+          # Fall back to the current file if we can't find it
+          __FILE__
+        end
+
+        # Return directory containing the class definition
+        File.dirname(path || __FILE__)
+      end
+
+      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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "open3"
+require "yaml"
+
+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
+      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"] || []
+
+        # Process tools configuration
+        parse_tools
+
+        # Process function-specific configurations
+        parse_functions
+
+        # Read the target parameter
+        @target = options[:target] || @config_hash["target"]
+
+        # Process the target command if it's a shell command
+        @target = process_target(@target) if has_target?
+      end
+
+      def context_path
+        @context_path ||= File.dirname(workflow_path)
+      end
+
+      def basename
+        @basename ||= File.basename(workflow_path, ".yml")
+      end
+
+      def has_target?
+        !target.nil? && !target.empty?
+      end
+
+      def get_step_config(step_name)
+        @config_hash[step_name] || {}
+      end
+
+      def find_step_index(steps, target_step)
+        steps.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"] || {}
+      end
+
+      # Get configuration for a specific function
+      # @param function_name [String, Symbol] The name of the function (e.g., 'grep', 'search_file')
+      # @return [Hash] The configuration for the function or empty hash if not found
+      def function_config(function_name)
+        @function_configs[function_name.to_s] || {}
+      end
+
+      private
+
+      def process_target(command)
+        # If it's a bash command with the new $(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
+
+        # 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")
+        end
+
+        # assumed to be a direct file path(s)
+        File.expand_path(command)
+      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) }
+        end
+      end
+    end
+  end
+end

data/lib/roast/workflow/configuration_parser.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "workflow_executor"
+require_relative "configuration"
+require_relative "../helpers/function_caching_interceptor"
+
+module Roast
+  module Workflow
+    class ConfigurationParser
+      extend Forwardable
+
+      attr_reader :configuration, :options, :files, :current_workflow
+
+      def_delegator :current_workflow, :output
+
+      def initialize(workflow_path, files = [], options = {})
+        @configuration = Configuration.new(workflow_path, options)
+        @options = options
+        @files = files
+        include_tools
+      end
+
+      def begin!
+        $stderr.puts "Starting workflow..."
+        $stderr.puts "Workflow: #{configuration.workflow_path}"
+        $stderr.puts "Options: #{options}"
+
+        name = configuration.basename
+        context_path = configuration.context_path
+
+        if files.any?
+          $stderr.puts "WARNING: Ignoring target parameter because files were provided: #{configuration.target}" if configuration.has_target?
+          files.each do |file|
+            $stderr.puts "Running workflow for file: #{file}"
+            setup_workflow(file.strip, name:, context_path:)
+            parse(configuration.steps)
+          end
+        elsif configuration.has_target?
+          configuration.target.lines.each do |file|
+            $stderr.puts "Running workflow for file: #{file.strip}"
+            setup_workflow(file.strip, name:, context_path:)
+            parse(configuration.steps)
+          end
+        else
+          $stdout.puts "🚫 ERROR: No files or target provided! 🚫"
+        end
+      end
+
+      private
+
+      def setup_workflow(file, name:, context_path:)
+        @current_workflow = BaseWorkflow.new(file, name:, context_path:).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?
+        end
+      end
+
+      def include_tools
+        return unless configuration.tools.present?
+
+        BaseWorkflow.include(Raix::FunctionDispatch)
+        BaseWorkflow.include(Roast::Helpers::FunctionCachingInterceptor) # Add caching support
+        BaseWorkflow.include(*configuration.tools.map(&:constantize))
+      end
+
+      def parse(steps)
+        return run(steps) if steps.is_a?(String)
+
+        # 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 results to file if specified
+        if current_workflow.output_file
+          File.write(current_workflow.output_file, current_workflow.final_output)
+          $stdout.puts "Results saved to #{current_workflow.output_file}"
+        else
+          $stdout.puts current_workflow.final_output
+        end
+      end
+
+      # Delegates to WorkflowExecutor
+      def run(name)
+        executor = WorkflowExecutor.new(current_workflow, configuration.config_hash, configuration.context_path)
+        executor.execute_step(name)
+      end
+    end
+  end
+end

data/lib/roast/workflow/validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "json-schema"
+require "json"
+require "yaml"
+
+module Roast
+  module Workflow
+    class Validator
+      attr_reader :errors
+
+      def initialize(yaml_content)
+        @yaml_content = yaml_content&.strip || ""
+        @errors = []
+
+        @parsed_yaml = @yaml_content.empty? ? {} : YAML.safe_load(@yaml_content)
+      end
+
+      def valid?
+        return false if @parsed_yaml.empty?
+
+        schema_path = File.join(Roast::ROOT, "schema/workflow.json")
+        schema = JSON.parse(File.read(schema_path))
+
+        begin
+          @errors = JSON::Validator.fully_validate(
+            schema,
+            @parsed_yaml,
+            validate_schema: false,
+          )
+
+          @errors.empty?
+        end
+      end
+    end
+  end
+end