roast-ai 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bdaada020320af4c7fead86184a7cd0b1c06a89e88bc15ac424b31f4b449fb6
-  data.tar.gz: 3f83f410a1f21992de59b19b8e2f0ea402b9fe50b314b82514723cf20f9a599f
+  metadata.gz: 40bb03c596dcaa3dd49685c9b5f804ca6c6db00cf239d5e52748e6fa485f9c3b
+  data.tar.gz: c56399cca493aa9d925bb4d0550dc7ad0c0ed03b74b4f7894a3205ba72e66d1e
 SHA512:
-  metadata.gz: c6dfdd57104e363735a6e24bf5beb43a042340f582f94d8126c3f8a0d30dd92b031c5201a7d3d136bfcd3b7095a51c49329b08c07c5c19544240b18e20ad9948
-  data.tar.gz: 02aec8d620c3fe0c57d0d4e06790a7513a4a1aa44f68462721b6aa7da3f22f377598b4c00453e4ec825b0adcac3c335d470f945599d39571edb67e8a380597ac
+  metadata.gz: 2560cd52f21eb2aa0c954d1759ac762c12f2840a1533cc41017003a022f002212e9fb8d6e6b3d11fc1245ff413a86bd68d3aad7a142de9a30d4c534277a80f51
+  data.tar.gz: 371d573330873f1e76aec168e72ed8e2c53d0a127af83683205fae7d060dfa758aeb2352133b4f8b263803b5384b77be76b91a564d945cfd8966a682959a0d13

data/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.7] - 2024-05-16
+
+### Added
+- `UpdateFiles` tool for applying diffs/patches to multiple files at once
+- Support for atomic file updates with rollback capability
+- Comprehensive documentation for all built-in tools
+- Enhanced README with detailed tool usage examples
+
 ## [0.1.6] - 2024-05-15
 
 ### Added
@@ -25,6 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Improved initializer loading and error handling
 - Fixed tests for nested .roast folders
 
+[0.1.7]: https://github.com/Shopify/roast/compare/v0.1.6...v0.1.7
 [0.1.6]: https://github.com/Shopify/roast/compare/v0.1.5...v0.1.6
 
 ## [0.1.5] - 2024-05-13

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    roast-ai (0.1.6)
+    roast-ai (0.1.7)
       activesupport (~> 8.0)
+      diff-lcs (~> 1.5)
       faraday-retry
       json-schema
       raix (~> 0.8.4)
@@ -37,6 +38,7 @@ GEM
     crack (1.0.0)
       bigdecimal
       rexml
+    diff-lcs (1.6.1)
     dotenv (3.1.8)
     drb (2.2.1)
     event_stream_parser (1.0.0)

data/README.md

@@ -385,6 +385,151 @@ For most workflows, you'll mainly use `response` to access the current step's re
 
 Roast provides extensive instrumentation capabilities using ActiveSupport::Notifications. You can monitor workflow execution, track AI model usage, measure performance, and integrate with external monitoring systems. [Read the full instrumentation documentation](docs/INSTRUMENTATION.md).
 
+### Built-in Tools
+
+Roast provides several built-in tools that you can use in your workflows:
+
+#### ReadFile
+
+Reads the contents of a file from the filesystem.
+
+```ruby
+# Basic usage
+read_file(path: "path/to/file.txt")
+
+# Reading a specific portion of a file
+read_file(path: "path/to/large_file.txt", offset: 100, limit: 50)
+```
+
+- The `path` can be absolute or relative to the current working directory
+- Use `offset` and `limit` for large files to read specific sections (line numbers)
+- Returns the file content as a string
+
+#### WriteFile
+
+Writes content to a file, creating the file if it doesn't exist or overwriting it if it does.
+
+```ruby
+# Basic usage
+write_file(path: "output.txt", content: "This is the file content")
+
+# With path restriction for security
+write_file(
+  path: "output.txt",
+  content: "Restricted content",
+  restrict: "/safe/directory" # Only allows writing to files under this path
+)
+```
+
+- Creates missing directories automatically
+- Can restrict file operations to specific directories for security
+- Returns a success message with the number of lines written
+
+#### UpdateFiles
+
+Applies a unified diff/patch to one or more files. Changes are applied atomically when possible.
+
+```ruby
+update_files(
+  diff: <<~DIFF,
+    --- a/file1.txt
+    +++ b/file1.txt
+    @@ -1,3 +1,4 @@
+     line1
+    +new line
+     line2
+     line3
+    
+    --- a/file2.txt
+    +++ b/file2.txt
+    @@ -5,7 +5,7 @@
+     line5
+     line6
+    -old line7
+    +updated line7
+     line8
+  DIFF
+  base_path: "/path/to/project", # Optional, defaults to current working directory
+  restrict_path: "/path/to/allowed", # Optional, restricts where files can be modified
+  create_files: true, # Optional, defaults to true
+)
+```
+
+- Accepts standard unified diff format from tools like `git diff`
+- Supports multiple file changes in a single operation
+- Handles file creation, deletion, and modification
+- Performs atomic operations with rollback on failure
+- Includes fuzzy matching to handle minor context differences
+- This tool is especially useful for making targeted changes to multiple files at once
+
+#### Grep
+
+Searches file contents for a specific pattern using regular expressions.
+
+```ruby
+# Basic usage
+grep(pattern: "function\\s+myFunction")
+
+# With file filtering
+grep(pattern: "class\\s+User", include: "*.rb")
+
+# With directory scope
+grep(pattern: "TODO:", path: "src/components")
+```
+
+- Uses regular expressions for powerful pattern matching
+- Can filter by file types using the `include` parameter
+- Can scope searches to specific directories with the `path` parameter
+- Returns a list of files containing matches
+
+#### SearchFile
+
+Provides advanced file search capabilities beyond basic pattern matching.
+
+```ruby
+search_file(query: "class User", file_path: "app/models")
+```
+
+- Combines pattern matching with contextual search
+- Useful for finding specific code structures or patterns
+- Returns matched lines with context
+
+#### Cmd
+
+Executes shell commands and returns their output.
+
+```ruby
+# Execute a simple command
+cmd(command: "ls -la")
+
+# With working directory specified
+cmd(command: "npm list", cwd: "/path/to/project")
+
+# With environment variables
+cmd(command: "deploy", env: { "NODE_ENV" => "production" })
+```
+
+- Provides access to shell commands for more complex operations
+- Can specify working directory and environment variables
+- Captures and returns command output
+- Useful for integrating with existing tools and scripts
+
+#### CodingAgent
+
+Creates a specialized agent for complex coding tasks or long-running operations.
+
+```ruby
+coding_agent(
+  task: "Refactor the authentication module to use JWT tokens",
+  language: "ruby",
+  files: ["app/models/user.rb", "app/controllers/auth_controller.rb"]
+)
+```
+
+- Delegates complex tasks to a specialized coding agent
+- Useful for tasks that require deep code understanding or multi-step changes
+- Can work across multiple files and languages
+
 ### Custom Tools
 
 You can create your own tools using the [Raix function dispatch pattern](https://github.com/OlympiaAI/raix-rails?tab=readme-ov-file#use-of-toolsfunctions). Custom tools should be placed in `.roast/initializers/` (subdirectories are supported):

data/docs/INSTRUMENTATION.md

@@ -199,4 +199,45 @@ Then run:
 roast execute test_instrumentation.yml some_file.rb
 ```
 
-Your instrumentation should capture the workflow start, step execution, and workflow completion events.
+Your instrumentation should capture the workflow start, step execution, and workflow completion events.
+
+## Available Tools
+
+Roast provides several built-in tools that you can use in your workflows:
+
+### WriteFile Tool
+
+Writes content to a file, creating the file if it doesn't exist or overwriting it if it does.
+
+```ruby
+# Example usage in a prompt
+write_file(path: "output.txt", content: "This is the file content")
+```
+
+### UpdateFiles Tool
+
+Applies a unified diff/patch to one or more files. Changes are applied atomically when possible.
+
+```ruby
+# Example usage in a prompt
+update_files(diff: <<~DIFF, base_path: "/path/to/project", create_files: true)
+  --- a/file1.txt
+  +++ b/file1.txt
+  @@ -1,3 +1,4 @@
+   line1
+  +new line
+   line2
+   line3
+  
+  --- a/file2.txt
+  +++ b/file2.txt
+  @@ -5,7 +5,7 @@
+   line5
+   line6
+  -old line7
+  +updated line7
+   line8
+DIFF
+```
+
+This tool is especially useful for making targeted changes to multiple files at once, without having to replace entire file contents.

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.6"
+  VERSION = "0.1.7"
 end

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")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roast-ai
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Shopify
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: diff-lcs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
@@ -169,6 +183,7 @@ files:
 - lib/roast/tools/grep.rb
 - lib/roast/tools/read_file.rb
 - lib/roast/tools/search_file.rb
+- lib/roast/tools/update_files.rb
 - lib/roast/tools/write_file.rb
 - lib/roast/version.rb
 - lib/roast/workflow.rb