roast-ai 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e40b7ab08d8d4c70d9d884c2c76027ad1426bcdacbae92121b162cc33aa45548
-  data.tar.gz: 936ab6e40dfbfbcef29f68edbb1a7ea41a895d719782f2125c24f47e71005eeb
+  metadata.gz: bc0fd34418eef0f9546d55ab30407287745c6f96664b57b29050eeecfd0751e9
+  data.tar.gz: ee09de492428972903a8d69a768b9b661e8668c1aebe51fa5d156e01d41beb41
 SHA512:
-  metadata.gz: 7c8de8b0ac1ee9496a869d056fb75de2101b4f1b674bde76c703a913ae749d22c650b44c783e8ebff4127862baa168e4ba1680f1e62bd60574068ba53c88f154
-  data.tar.gz: f770140fee92dd287d171c52b61d437bbbb3ad7bbe0edc121c68cdb71d4b7628ebbbe1e56946cd8a251ecb991e803e79e62f7d084d59a0efc0efc2ce30b13769
+  metadata.gz: c8458190fd1fe4b21e80f1fe038f104c55f40a9bfcd0cef5ef1d66aacf25d783b7ff4c82940adeda90cc60914906e03ef3f83373c97e3880e87e62a7e5da0f17
+  data.tar.gz: 34f621a2ebc7f5074d161271e5babf1c2f20e5492c483e8b45a2be217c241d577e46251db19356e59c818d54c1e999b35225e1793f6380d639a04358b94e36eb

data/.github/workflows/ci.yaml

@@ -16,7 +16,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu]
-        ruby: ['3.4', 'ruby-head']
+        ruby: ['3.4']
     runs-on: ${{ matrix.os }}-latest
     continue-on-error: ${{ matrix.ruby == 'ruby-head' }}
     steps:

data/CHANGELOG.md

@@ -5,7 +5,25 @@ 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.3] - 2024-05-10
+## [0.1.5] - 2024-05-13
+
+### Added
+- Interpolation feature for dynamic workflows using `{{}}` syntax
+- Support for injecting values from workflow context into step names and commands
+- Ability to access file metadata and step outputs using interpolation expressions
+- Examples demonstrating interpolation usage with different file types
+
+[0.1.5]: https://github.com/Shopify/roast/releases/tag/v0.1.5
+
+## [0.1.4] - 2024-05-13
+
+### Fixed
+- Remove test directory restriction from WriteTool. (Thank you @endoze)
+
+[0.1.4]: https://github.com/Shopify/roast/releases/tag/v0.1.4
+
+
+## [0.1.3] - 2024-05-12
 
 ### Fixed
 - ReadFile tool now handles absolute and relative paths correctly

data/Gemfile

@@ -7,6 +7,7 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in roast.gemspec
 gemspec
 
+gem "cgi"
 gem "dotenv"
 gem "guard-rspec"
 gem "guard"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roast-ai (0.1.3)
+    roast-ai (0.1.5)
       activesupport (~> 8.0)
       faraday-retry
       json-schema
@@ -30,6 +30,7 @@ GEM
     base64 (0.2.0)
     benchmark (0.4.0)
     bigdecimal (3.1.9)
+    cgi (0.4.2)
     coderay (1.1.3)
     concurrent-ruby (1.3.5)
     connection_pool (2.5.1)
@@ -178,6 +179,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  cgi
   dotenv
   guard
   guard-rspec

data/README.md

@@ -53,15 +53,15 @@ steps:
   - generate_final_report
 ```
 
-Workflows can include steps that run bash commands (wrap in `$()`) and even simple inlined prompts as a natural language string.
+Workflows can include steps that run bash commands (wrap in `$()`), use interpolation with `{{}}` syntax, and even simple inlined prompts as a natural language string.
 
 ```yaml
 steps:
   - analyze_spec
   - create_minitest
   - run_and_improve
-  - $(bundle exec rubocop -A)
-  - Summarize the changes made to the codebase.
+  - $(bundle exec rubocop -A {{file}})
+  - Summarize the changes made to {{File.basename(file)}}.
 ```
 
 ## How to use Roast
@@ -122,7 +122,7 @@ Roast supports several types of steps:
 
 #### Data Flow Between Steps
 
-Roast handles data flow between steps in two primary ways:
+Roast handles data flow between steps in three primary ways:
 
 1. **Conversation Context (Implicit)**: The LLM naturally remembers the entire conversation history, including all previous prompts and responses. In most cases, this is all you need for a step to reference and build upon previous results. This is the preferred approach for most prompt-oriented workflows.
 
@@ -131,7 +131,21 @@ Roast handles data flow between steps in two primary ways:
    - You're writing custom output logic
    - You need to access specific values for presentation or logging
 
-For typical AI workflows, the continuous conversation history provides seamless data flow without requiring explicit access to the output hash. Steps can simply refer to previous information in their prompts, and the AI model will use its memory of the conversation to provide context-aware responses.
+3. **Interpolation (Dynamic)**: You can use `{{expression}}` syntax to inject values from the workflow context directly into step names, commands, or prompt text. For example:
+   ```yaml
+   steps:
+     - analyze_file
+     - $(rubocop -A {{file}})
+     - Generate a summary for {{file}}
+     - result_for_{{file}}: store_results
+   ```
+   
+   Interpolation supports:
+   - Simple variable access: `{{file}}`, `{{resource.target}}`
+   - Access to step outputs: `{{output['previous_step']}}`
+   - Any valid Ruby expression evaluated in the workflow context: `{{File.basename(file)}}`
+
+For typical AI workflows, the continuous conversation history provides seamless data flow without requiring explicit access to the output hash. Steps can simply refer to previous information in their prompts, and the AI model will use its memory of the conversation to provide context-aware responses. For more dynamic requirements, the interpolation syntax provides a convenient way to inject context-specific values into steps.
 
 ### Command Line Options
 

data/examples/interpolation/README.md

@@ -0,0 +1,50 @@
+# Interpolation Example
+
+This example demonstrates how to use Roast's interpolation feature to create dynamic workflows.
+
+## Overview
+
+The workflow in this example:
+1. Analyzes a file and extracts its metadata
+2. Extracts patterns based on the file type
+3. Dynamically selects a report generation step based on the file extension
+4. Outputs a completion message using the file's basename
+
+## Interpolation Examples
+
+The workflow demonstrates several types of interpolation:
+
+- `{{ }}` syntax for embedding dynamic values
+- Access to file metadata via expressions like `{{file_basename}}` and `{{file_ext}}`
+- Dynamic step selection with `generate_report_for_{{file_ext}}`
+- Shell command interpolation with `$(echo "Processing completed for file: {{file_basename}}")`
+
+## Running the Example
+
+To run this example with a Ruby file:
+
+```bash
+roast execute workflow.yml /path/to/some_file.rb
+```
+
+Or with a JavaScript file:
+
+```bash
+roast execute workflow.yml /path/to/some_file.js
+```
+
+The workflow will:
+1. Extract the file's basename and extension
+2. Store these in the workflow context
+3. Dynamically choose a report generator based on file extension
+4. Create a markdown report file
+5. Output a completion message with the filename
+
+## How Interpolation Works
+
+1. When Roast processes a step name or shell command, it looks for `{{ }}` patterns
+2. Expressions inside `{{ }}` are evaluated in the workflow's context using Ruby's `instance_eval`
+3. This allows access to the workflow's variables, methods, and output hash
+4. The evaluated expressions replace the `{{ }}` patterns in the step name or command
+
+This makes workflows dynamic and able to respond to different inputs without code changes.

data/examples/interpolation/analyze_file/prompt.md

@@ -0,0 +1,13 @@
+# File Analysis
+
+I'm going to analyze the file at: <%= workflow.file %>
+
+First, let me gather some basic information about the file:
+
+1. File name: `<%= File.basename(workflow.file) %>`
+2. File extension: `<%= File.extname(workflow.file).sub('.', '') %>`
+3. File size: `<%= File.size(workflow.file) %> bytes`
+
+---
+
+Can you read the file for me so I can analyze it?

data/examples/interpolation/analyze_patterns/prompt.md

@@ -0,0 +1,27 @@
+Extract some patterns about this file and return in json format like this:
+
+<json>
+{
+  "code_patterns": {
+    "class_structure": {
+      "name": "Calculator",
+      "instance_variables": ["@memory"],
+      "method_count": 7,
+      "method_types": {
+        "constructor": ["initialize"],
+        "operations": ["add", "subtract", "multiply", "divide"],
+        "accessors": ["memory"],
+        "utility": ["clear"]
+      }
+    },
+    "error_handling": {
+      "techniques": ["conditional raise", "zero check"],
+      "examples": ["raise \"Division by zero!\" if number.zero?"]
+    },
+    "design_patterns": {
+      "state": "Uses instance variable to maintain calculator state",
+      "command": "Each operation method modifies the internal state"
+    }
+  }
+}
+</json>

data/examples/interpolation/generate_report_for_js/prompt.md

@@ -0,0 +1,28 @@
+# JavaScript File Report Generation
+
+I'm generating a report for a JavaScript file:
+
+- File name: `<%= workflow.output['file_basename'] %>`
+- Lines: `<%= workflow.output['patterns_found']['lines'] %>`
+
+## JavaScript-Specific Report
+
+JavaScript files typically contain functions, classes, and import/export statements. I'll generate a report focused on JavaScript code analysis.
+
+### Recommendations for JavaScript Code
+
+1. Follow a consistent style guide (ESLint)
+2. Use modern JavaScript features (ES6+)
+3. Prefer const and let over var
+4. Use async/await for asynchronous code
+5. Write unit tests with Jest or Mocha
+
+### Summary
+
+This JavaScript file has been analyzed and basic metrics have been collected. A more detailed analysis would involve parsing the JavaScript code to extract functions, classes, and import/export statements.
+
+I'll create a report file with this information.
+
+I'll use my WriteFile tool to generate the report.
+
+Can you please write the report to `report_<%= workflow.output['file_basename'] %>.md` in the current directory?

data/examples/interpolation/generate_report_for_rb/prompt.md

@@ -0,0 +1,3 @@
+Generate a nicely formatted report based on the following metadata:
+
+<%= workflow.output[:extract_info] %>

data/examples/interpolation/sample.js

@@ -0,0 +1,48 @@
+// Sample JavaScript file for testing interpolation in workflows
+
+class Calculator {
+  constructor() {
+    this.memory = 0;
+  }
+
+  add(number) {
+    this.memory += number;
+    return this.memory;
+  }
+
+  subtract(number) {
+    this.memory -= number;
+    return this.memory;
+  }
+
+  multiply(number) {
+    this.memory *= number;
+    return this.memory;
+  }
+
+  divide(number) {
+    if (number === 0) {
+      throw new Error("Division by zero!");
+    }
+    this.memory /= number;
+    return this.memory;
+  }
+
+  getMemory() {
+    return this.memory;
+  }
+
+  clear() {
+    this.memory = 0;
+    return this.memory;
+  }
+}
+
+// Example usage
+if (require.main === module) {
+  const calc = new Calculator();
+  calc.add(10);
+  calc.multiply(2);
+  calc.subtract(5);
+  console.log(`Result: ${calc.getMemory()}`);
+}

data/examples/interpolation/sample.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Sample Ruby file for testing interpolation in workflows
+
+class Calculator
+  def initialize
+    @memory = 0
+  end
+
+  def add(number)
+    @memory += number
+  end
+
+  def subtract(number)
+    @memory -= number
+  end
+
+  def multiply(number)
+    @memory *= number
+  end
+
+  def divide(number)
+    raise "Division by zero!" if number.zero?
+
+    @memory /= number
+  end
+
+  attr_reader :memory
+
+  def clear
+    @memory = 0
+  end
+end
+
+# Example usage
+if __FILE__ == $PROGRAM_NAME
+  calc = Calculator.new
+  calc.add(10)
+  calc.multiply(2)
+  calc.subtract(5)
+  puts "Result: #{calc.memory}"
+end

data/examples/interpolation/workflow.md

@@ -0,0 +1 @@
+You are a good robot.

data/examples/interpolation/workflow.yml

@@ -0,0 +1,23 @@
+name: interpolation_example
+model: anthropic:claude-3-7-sonnet
+
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::WriteFile
+  - Roast::Tools::Grep
+
+steps:
+  - analyze_file
+  - extract_info: analyze_patterns
+  - generate_report_for_{{File.extname(workflow.file).sub('.', '')}}
+  - '$(echo "Processing completed for file: {{File.basename(workflow.file)}}")'
+
+analyze_patterns:
+  json: true
+
+generate_report_for_rb:
+  print_response: true
+
+generate_report_for_md:
+  print_response: true
+  

data/lib/roast/tools/write_file.rb

@@ -21,7 +21,9 @@ module Roast
               },
               content: { type: "string", description: "The content to write to the file" },
             ) do |params|
-              Roast::Tools::WriteFile.call(params[:path], params[:content]).tap do |_result|
+              restrict_path = params[:params]&.dig("restrict")
+
+              Roast::Tools::WriteFile.call(params[:path], params[:content], restrict_path).tap do |_result|
                 Roast::Helpers::Logger.info(params[:content])
               end
             end
@@ -29,9 +31,8 @@ module Roast
         end
       end
 
-      def call(path, content)
-        if path.start_with?("test/")
-
+      def call(path, content, restrict_path = nil)
+        if restrict_path.nil? || restrict_path.empty? || path.start_with?(restrict_path)
           Roast::Helpers::Logger.info("📝 Writing to file: #{path}\n")
 
           # Ensure the directory exists
@@ -46,8 +47,9 @@ module Roast
 
           "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."
+          restriction_message = "😳 Path must start with '#{restrict_path}' to use the write_file tool\n"
+          Roast::Helpers::Logger.error(restriction_message)
+          "Error: Path must start with '#{restrict_path}' to use the write_file tool, try again."
         end
       rescue StandardError => e
         "Error writing file: #{e.message}".tap do |error_message|

data/lib/roast/version.rb

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

data/lib/roast/workflow/base_workflow.rb

@@ -100,6 +100,10 @@ module Roast
         raise
       end
 
+      def workflow
+        self
+      end
+
       private
 
       # Determine the directory where the actual class is defined, not BaseWorkflow

data/lib/roast/workflow/workflow_executor.rb

@@ -33,6 +33,25 @@ module Roast
         end
       end
 
+      # Interpolates {{expression}} in a string with values from the workflow context
+      def interpolate(text)
+        return text unless text.is_a?(String) && text.include?("{{") && text.include?("}}")
+
+        # Replace all {{expression}} with their evaluated values
+        text.gsub(/\{\{([^}]+)\}\}/) do |match|
+          expression = Regexp.last_match(1).strip
+          begin
+            # Evaluate the expression in the workflow's context
+            workflow.instance_eval(expression).to_s
+          rescue => e
+            # If evaluation fails, provide a more detailed error message but preserve the original expression
+            error_msg = "Error interpolating {{#{expression}}}: #{e.message}. This variable is not defined in the workflow context. Please define it before using it in a step name."
+            $stderr.puts "ERROR: #{error_msg}"
+            match # Return the original match to preserve it in the string
+          end
+        end
+      end
+
       def execute_step(name)
         start_time = Time.now
         # For tests, make sure that we handle this gracefully
@@ -95,10 +114,16 @@ module Roast
       def execute_hash_step(step)
         # execute a command and store the output in a variable
         name, command = step.to_a.flatten
+
+        # Interpolate variable name if it contains {{}}
+        interpolated_name = interpolate(name)
+
         if command.is_a?(Hash)
           execute_steps([command])
         else
-          workflow.output[name] = execute_step(command)
+          # Interpolate command value
+          interpolated_command = interpolate(command)
+          workflow.output[interpolated_name] = execute_step(interpolated_command)
         end
       end
 
@@ -110,7 +135,9 @@ module Roast
       end
 
       def execute_string_step(step)
-        execute_step(step)
+        # Interpolate any {{}} expressions before executing the step
+        interpolated_step = interpolate(step)
+        execute_step(interpolated_step)
       end
 
       def find_and_load_step(step_name)
@@ -172,7 +199,11 @@ module Roast
 
       def strip_and_execute(step)
         if step.match?(/^\$\((.*)\)$/)
+          # Extract the command from the $(command) syntax
           command = step.strip.match(/^\$\((.*)\)$/)[1]
+
+          # NOTE: We don't need to call interpolate here as it's already been done
+          # in execute_string_step before this method is called
           %x(#{command})
         else
           raise "Missing closing parentheses: #{step}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roast-ai
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Shopify
@@ -128,6 +128,15 @@ files:
 - examples/grading/workflow.ts+tsx.md
 - examples/grading/workflow.yml
 - examples/instrumentation.rb
+- examples/interpolation/README.md
+- examples/interpolation/analyze_file/prompt.md
+- examples/interpolation/analyze_patterns/prompt.md
+- examples/interpolation/generate_report_for_js/prompt.md
+- examples/interpolation/generate_report_for_rb/prompt.md
+- examples/interpolation/sample.js
+- examples/interpolation/sample.rb
+- examples/interpolation/workflow.md
+- examples/interpolation/workflow.yml
 - examples/rspec_to_minitest/README.md
 - examples/rspec_to_minitest/analyze_spec/prompt.md
 - examples/rspec_to_minitest/create_minitest/prompt.md