roast-ai 0.1.5 → 0.1.7

data/examples/openrouter_example/workflow.yml

@@ -0,0 +1,12 @@
+name: OpenRouter Example
+api_provider: openrouter
+api_token: $(echo $OPENROUTER_API_KEY)
+model: anthropic/claude-3-haiku-20240307
+
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::WriteFile
+
+steps:
+  - analyze_input
+  - generate_response

data/lib/roast/initializers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Roast
+  class Initializers
+    class << self
+      def config_root(starting_path = Dir.pwd, ending_path = File.dirname(Dir.home))
+        paths = []
+        candidate = starting_path
+        while candidate != ending_path
+          paths << File.join(candidate, ".roast")
+          candidate = File.dirname(candidate)
+        end
+
+        first_existing = paths.find { |path| Dir.exist?(path) }
+        first_existing || paths.first
+      end
+
+      def initializers_path
+        File.join(Roast::Initializers.config_root, "initializers")
+      end
+
+      def load_all
+        project_initializers = Roast::Initializers.initializers_path
+        return unless Dir.exist?(project_initializers)
+
+        $stderr.puts "Loading project initializers from #{project_initializers}"
+        pattern = File.join(project_initializers, "**/*.rb")
+        Dir.glob(pattern, sort: true).each do |file|
+          $stderr.puts "Loading initializer: #{file}"
+          require file
+        end
+      rescue => e
+        puts "ERROR: Error loading initializers: #{e.message}"
+        Roast::Helpers::Logger.error("Error loading initializers: #{e.message}")
+        # Don't fail the workflow if initializers can't be loaded
+      end
+    end
+  end
+end

data/lib/roast/tools/search_file.rb

@@ -13,10 +13,11 @@ module Roast
           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" },
+              "Search for a file in the project using a glob pattern.",
+              glob_pattern: { type: "string", description: "A glob pattern to search for. Example: 'test/**/*_test.rb'" },
+              path: { type: "string", description: "path to search from" },
             ) do |params|
-              Roast::Tools::SearchFile.call(params[:name]).tap do |result|
+              Roast::Tools::SearchFile.call(params[:glob_pattern], params[:path]).tap do |result|
                 Roast::Helpers::Logger.debug(result) if ENV["DEBUG"]
               end
             end
@@ -24,27 +25,33 @@ module Roast
         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
+      def call(glob_pattern, path = ".")
+        Roast::Helpers::Logger.info("🔍 Searching for: '#{glob_pattern}' in '#{path}'\n")
+        search_for(glob_pattern, path).then do |results|
+          return "No results found for #{glob_pattern} in #{path}" if results.empty?
+          return read_contents(results.first) if results.size == 1
 
-          results.inspect # purposely give the AI list of actual paths so that it can read without searching first
+          results.join("\n") # 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|
+        "Error searching for '#{glob_pattern}' in '#{path}': #{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
+      def read_contents(path)
+        contents = File.read(path)
+        token_count = contents.size / 4
+        if token_count > 25_000
+          path
+        else
+          contents
+        end
+      end
 
-        # Split by newlines and get the first result
-        result.split("\n").map(&:strip).reject(&:empty?).map { |path| path.sub(%r{^\./}, "") }
+      def search_for(pattern, path)
+        Dir.glob(pattern, base: path)
       end
     end
   end

data/lib/roast/tools/update_files.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "roast/helpers/logger"
+require "diff/lcs"
+
+module Roast
+  module Tools
+    module UpdateFiles
+      extend self
+
+      class << self
+        # Add this method to be included in other classes
+        def included(base)
+          base.class_eval do
+            function(
+              :update_files,
+              "Apply a unified diff/patch to files in the workspace. Changes are applied atomically if possible.",
+              diff: {
+                type: "string",
+                description: "The unified diff/patch content to apply",
+              },
+              base_path: {
+                type: "string",
+                description: "Base path for relative file paths in the diff (default: current working directory)",
+                required: false,
+              },
+              restrict_path: {
+                type: "string",
+                description: "Optional path restriction to limit where files can be modified",
+                required: false,
+              },
+              create_files: {
+                type: "boolean",
+                description: "Whether to create new files if they don't exist (default: true)",
+                required: false,
+              },
+            ) do |params|
+              base_path = params[:base_path] || Dir.pwd
+              create_files = params.fetch(:create_files, true)
+              restrict_path = params[:restrict_path]
+
+              Roast::Tools::UpdateFiles.call(
+                params[:diff],
+                base_path,
+                restrict_path,
+                create_files,
+              )
+            end
+          end
+        end
+      end
+
+      # Apply a unified diff to files
+      # @param diff [String] unified diff content
+      # @param base_path [String] base path for relative paths in the diff
+      # @param restrict_path [String, nil] optional path restriction
+      # @param create_files [Boolean] whether to create new files if they don't exist
+      # @return [String] result message
+      def call(diff, base_path = Dir.pwd, restrict_path = nil, create_files = true)
+        Roast::Helpers::Logger.info("🔄 Applying patch to files\n")
+
+        # Parse the unified diff to identify files and changes
+        file_changes = parse_unified_diff(diff)
+
+        if file_changes.empty?
+          return "Error: No valid file changes found in the provided diff"
+        end
+
+        # Validate changes
+        validation_result = validate_changes(file_changes, base_path, restrict_path, create_files)
+        return validation_result if validation_result.is_a?(String) && validation_result.start_with?("Error:")
+
+        # Apply changes atomically
+        apply_changes(file_changes, base_path, create_files)
+      rescue StandardError => e
+        "Error applying patch: #{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
+
+      # Parse a unified diff to extract file changes
+      # @param diff [String] unified diff content
+      # @return [Array<Hash>] array of file change objects
+      def parse_unified_diff(diff)
+        lines = diff.split("\n")
+        file_changes = []
+        current_files = { src: nil, dst: nil }
+        current_hunks = []
+
+        i = 0
+        while i < lines.length
+          line = lines[i]
+
+          # New file header (--- line followed by +++ line)
+          if line.start_with?("--- ") && i + 1 < lines.length && lines[i + 1].start_with?("+++ ")
+            # Save previous file if exists
+            if current_files[:src] && current_files[:dst] && !current_hunks.empty?
+              file_changes << {
+                src_path: current_files[:src],
+                dst_path: current_files[:dst],
+                hunks: current_hunks.dup,
+              }
+            end
+
+            # Extract new file paths
+            current_files = {
+              src: extract_file_path(line),
+              dst: extract_file_path(lines[i + 1]),
+            }
+            current_hunks = []
+            i += 2
+            next
+          end
+
+          # Hunk header
+          if line.match(/^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/)
+            current_hunk = { header: line, changes: [] }
+
+            # Parse the header
+            header_match = line.match(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/)
+            if header_match
+              current_hunk[:src_start] = header_match[1].to_i
+              current_hunk[:src_count] = header_match[2] ? header_match[2].to_i : 1 # rubocop:disable Metrics/BlockNesting
+              current_hunk[:dst_start] = header_match[3].to_i
+              current_hunk[:dst_count] = header_match[4] ? header_match[4].to_i : 1 # rubocop:disable Metrics/BlockNesting
+            end
+
+            current_hunks << current_hunk
+            i += 1
+            next
+          end
+
+          # Capture content lines for the current hunk
+          if !current_hunks.empty? && line.start_with?("+", "-", " ")
+            current_hunks.last[:changes] << line
+          end
+
+          i += 1
+        end
+
+        # Add the last file
+        if current_files[:src] && current_files[:dst] && !current_hunks.empty?
+          file_changes << {
+            src_path: current_files[:src],
+            dst_path: current_files[:dst],
+            hunks: current_hunks.dup,
+          }
+        end
+
+        file_changes
+      end
+
+      # Extract file path from a diff header line
+      # @param line [String] diff header line (--- or +++ line)
+      # @return [String] file path
+      def extract_file_path(line)
+        # Handle special cases
+        return "/dev/null" if line.include?("/dev/null")
+
+        # Remove prefixes
+        path = line.sub(%r{^(\+\+\+|\-\-\-) (a|b)/}, "")
+        # Handle files without 'a/' or 'b/' prefix
+        path = line.sub(/^(\+\+\+|\-\-\-) /, "") if path == line
+        # Remove timestamps if present
+        path = path.sub(/\t.*$/, "")
+        path
+      end
+
+      # Validate changes before applying them
+      # @param file_changes [Array<Hash>] array of file change objects
+      # @param base_path [String] base path for relative paths
+      # @param restrict_path [String, nil] optional path restriction
+      # @param create_files [Boolean] whether to create new files if they don't exist
+      # @return [Boolean, String] true if valid, error message if invalid
+      def validate_changes(file_changes, base_path, restrict_path, create_files)
+        # Validate each file in the changes
+        file_changes.each do |file_change|
+          # For destination files (they will be written to)
+          if file_change[:dst_path] && file_change[:dst_path] != "/dev/null"
+            absolute_path = File.expand_path(file_change[:dst_path], base_path)
+
+            # Check path restriction
+            if restrict_path && !absolute_path.start_with?(restrict_path)
+              return "Error: Path #{file_change[:dst_path]} must start with '#{restrict_path}' to use the update_files tool"
+            end
+
+            # Check if file exists
+            if !File.exist?(absolute_path) && !create_files
+              return "Error: File #{file_change[:dst_path]} does not exist and create_files is false"
+            end
+
+            # Check if file is readable and writable if it exists
+            if File.exist?(absolute_path)
+              unless File.readable?(absolute_path)
+                return "Error: File #{file_change[:dst_path]} is not readable"
+              end
+
+              unless File.writable?(absolute_path)
+                return "Error: File #{file_change[:dst_path]} is not writable"
+              end
+            end
+          end
+
+          # For source files (they will be read from)
+          next unless file_change[:src_path] && file_change[:src_path] != "/dev/null" && file_change[:src_path] != file_change[:dst_path]
+
+          absolute_path = File.expand_path(file_change[:src_path], base_path)
+
+          # Source file must exist unless it's a new file
+          if !File.exist?(absolute_path) && file_change[:src_path] != "/dev/null"
+            # Special case for new files (src: /dev/null)
+            if file_change[:src_path] != "/dev/null"
+              return "Error: Source file #{file_change[:src_path]} does not exist"
+            end
+          end
+
+          # Check if file is readable if it exists
+          next unless File.exist?(absolute_path)
+          unless File.readable?(absolute_path)
+            return "Error: Source file #{file_change[:src_path]} is not readable"
+          end
+        end
+
+        true
+      end
+
+      # Apply changes to files
+      # @param file_changes [Array<Hash>] array of file change objects
+      # @param base_path [String] base path for relative paths
+      # @param create_files [Boolean] whether to create new files if they don't exist
+      # @return [String] result message
+      def apply_changes(file_changes, base_path, create_files)
+        # Create a temporary backup of all files to be modified
+        backup_files = {}
+        modified_files = []
+
+        # Step 1: Create backups
+        file_changes.each do |file_change|
+          next unless file_change[:dst_path] && file_change[:dst_path] != "/dev/null"
+
+          absolute_path = File.expand_path(file_change[:dst_path], base_path)
+
+          if File.exist?(absolute_path)
+            backup_files[absolute_path] = File.read(absolute_path)
+          end
+        end
+
+        # Step 2: Try to apply all changes
+        begin
+          file_changes.each do |file_change|
+            next unless file_change[:dst_path]
+
+            # Special case for file deletion
+            if file_change[:dst_path] == "/dev/null" && file_change[:src_path] != "/dev/null"
+              absolute_src_path = File.expand_path(file_change[:src_path], base_path)
+              if File.exist?(absolute_src_path)
+                File.delete(absolute_src_path)
+                modified_files << file_change[:src_path]
+              end
+              next
+            end
+
+            # Skip if both src and dst are /dev/null (shouldn't happen but just in case)
+            next if file_change[:dst_path] == "/dev/null" && file_change[:src_path] == "/dev/null"
+
+            absolute_dst_path = File.expand_path(file_change[:dst_path], base_path)
+
+            # Special case for new files
+            if file_change[:src_path] == "/dev/null"
+              # For new files, ensure directory exists
+              dir = File.dirname(absolute_dst_path)
+              FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+              # Create the file with the added content
+              content = []
+              file_change[:hunks].each do |hunk|
+                hunk[:changes].each do |line|
+                  content << line[1..-1] if line.start_with?("+")
+                end
+              end
+
+              # Write the content
+              File.write(absolute_dst_path, content.join("\n") + (content.empty? ? "" : "\n"))
+              modified_files << file_change[:dst_path]
+              next
+            end
+
+            # Normal case: Modify existing file
+            content = ""
+            if File.exist?(absolute_dst_path)
+              content = File.read(absolute_dst_path)
+            else
+              # For new files that aren't from /dev/null, ensure directory exists
+              dir = File.dirname(absolute_dst_path)
+              FileUtils.mkdir_p(dir) unless File.directory?(dir)
+            end
+            content_lines = content.split("\n")
+
+            # Apply each hunk to the file
+            file_change[:hunks].each do |hunk|
+              # Apply the changes to the content
+              new_content_lines = apply_hunk(content_lines, hunk)
+
+              # Check if the hunk was applied successfully
+              if new_content_lines
+                content_lines = new_content_lines
+              else
+                raise "Hunk could not be applied cleanly: #{hunk[:header]}"
+              end
+            end
+
+            # Write the updated content
+            File.write(absolute_dst_path, content_lines.join("\n") + (content_lines.empty? ? "" : "\n"))
+            modified_files << file_change[:dst_path]
+          end
+
+          "Successfully applied patch to #{modified_files.size} file(s): #{modified_files.join(", ")}"
+        rescue StandardError => e
+          # Restore backups if any change fails
+          backup_files.each do |path, content|
+            File.write(path, content) if File.exist?(path)
+          end
+
+          "Error applying patch: #{e.message}"
+        end
+      end
+
+      # Apply a single hunk to file content
+      # @param content_lines [Array<String>] lines of file content
+      # @param hunk [Hash] hunk information
+      # @return [Array<String>, nil] updated content lines or nil if cannot apply
+      def apply_hunk(content_lines, hunk)
+        # For completely new files with no content
+        if content_lines.empty? && hunk[:src_start] == 1 && hunk[:src_count] == 0
+          # Just extract the added lines
+          return hunk[:changes].select { |line| line.start_with?("+") }.map { |line| line[1..-1] }
+        end
+
+        # For complete file replacement
+        if !content_lines.empty? &&
+            hunk[:src_start] == 1 &&
+            hunk[:changes].count { |line| line.start_with?("-") } >= content_lines.size
+          # Get only the added lines for the new content
+          return hunk[:changes].select { |line| line.start_with?("+") }.map { |line| line[1..-1] }
+        end
+
+        # Standard case with context matching
+        result = content_lines.dup
+        src_line = hunk[:src_start] - 1  # 0-based index
+        dst_line = hunk[:dst_start] - 1  # 0-based index
+
+        # Process each change line
+        hunk[:changes].each do |line|
+          if line.start_with?(" ") # Context line
+            # Verify context matches
+            if src_line >= result.size || result[src_line] != line[1..-1]
+              # Try to find the context nearby (fuzzy matching)
+              found = false
+              (-3..3).each do |offset|
+                check_pos = src_line + offset
+                next if check_pos < 0 || check_pos >= result.size
+
+                next unless result[check_pos] == line[1..-1]
+
+                src_line = check_pos
+                dst_line = check_pos
+                found = true
+                break
+              end
+
+              return nil unless found  # Context doesn't match, cannot apply hunk
+            end
+
+            src_line += 1
+            dst_line += 1
+          elsif line.start_with?("-")  # Removal
+            # Verify line exists and matches
+            if src_line >= result.size || result[src_line] != line[1..-1]
+              # Try to find the line nearby (fuzzy matching)
+              found = false
+              (-3..3).each do |offset|
+                check_pos = src_line + offset
+                next if check_pos < 0 || check_pos >= result.size
+
+                next unless result[check_pos] == line[1..-1]
+
+                src_line = check_pos
+                dst_line = check_pos
+                found = true
+                break
+              end
+
+              return nil unless found # Line to remove doesn't match, cannot apply hunk
+            end
+
+            # Remove the line
+            result.delete_at(src_line)
+          elsif line.start_with?("+") # Addition
+            # Insert the new line
+            result.insert(dst_line, line[1..-1])
+            dst_line += 1
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/roast/tools.rb

@@ -7,6 +7,7 @@ require "roast/tools/grep"
 require "roast/tools/read_file"
 require "roast/tools/search_file"
 require "roast/tools/write_file"
+require "roast/tools/update_files"
 require "roast/tools/cmd"
 require "roast/tools/coding_agent"
 

data/lib/roast/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Roast
-  VERSION = "0.1.5"
+  VERSION = "0.1.7"
 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, :api_token, :model, :resource
+      attr_reader :config_hash, :workflow_path, :name, :steps, :tools, :function_configs, :api_token, :api_provider, :model, :resource
       attr_accessor :target
 
       def initialize(workflow_path, options = {})
@@ -45,6 +45,9 @@ module Roast
           @api_token = process_shell_command(@config_hash["api_token"])
         end
 
+        # Determine API provider (defaults to OpenAI if not specified)
+        @api_provider = determine_api_provider
+
         # Extract default model if provided
         @model = @config_hash["model"]
       end
@@ -138,8 +141,32 @@ 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 =~ /^\$\((.*)\)$/

data/lib/roast/workflow/configuration_parser.rb

@@ -6,6 +6,7 @@ require_relative "../helpers/function_caching_interceptor"
 require "active_support"
 require "active_support/isolated_execution_state"
 require "active_support/notifications"
+require "raix"
 
 module Roast
   module Workflow
@@ -98,35 +99,23 @@ module Roast
       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
+        Roast::Initializers.load_all
       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"
+          case configuration.api_provider
+          when :openrouter
+            $stderr.puts "Configuring OpenRouter client with token from workflow"
+            require "open_router"
 
-          # 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)
+            Raix.configure do |config|
+              config.openrouter_client = OpenRouter::Client.new(api_key: configuration.api_token)
+            end
           else
+            $stderr.puts "Configuring OpenAI client with token from workflow"
             require "openai"
 
             Raix.configure do |config|

data/lib/roast.rb

@@ -7,6 +7,7 @@ require "roast/tools"
 require "roast/helpers"
 require "roast/resources"
 require "roast/workflow"
+require "roast/initializers"
 
 module Roast
   ROOT = File.expand_path("../..", __FILE__)
@@ -28,6 +29,11 @@ module Roast
       Roast::Workflow::ConfigurationParser.new(expanded_workflow_path, files, options.transform_keys(&:to_sym)).begin!
     end
 
+    desc "version", "Display the current version of Roast"
+    def version
+      puts "Roast version #{Roast::VERSION}"
+    end
+
     class << self
       def exit_on_failure?
         true

data/roast.gemspec

@@ -37,6 +37,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency("activesupport", "~> 8.0")
+  spec.add_dependency("diff-lcs", "~> 1.5")
   spec.add_dependency("faraday-retry")
   spec.add_dependency("json-schema")
   spec.add_dependency("raix", "~> 0.8.4")