roast-ai 0.1.0 → 0.1.2

data/examples/rspec_to_minitest/README.md

@@ -0,0 +1,68 @@
+# RSpec to Minitest Migration Workflow
+
+This workflow demonstrates how to automate the migration of RSpec tests to their Minitest equivalents, following a structured approach to ensure proper test coverage and functionality.
+
+## Workflow Overview
+
+The workflow consists of three main steps:
+
+1. **Analyze Spec**: Understand the purpose and structure of the RSpec test, including its dependencies and testing patterns.
+2. **Create Minitest**: Generate a new Minitest file with equivalent test coverage and assertions.
+3. **Run and Improve**: Execute the Minitest file and iteratively improve it until all tests pass.
+
+## Prerequisites
+
+- Ruby environment with both RSpec and Minitest gems installed
+- Access to the original codebase being tested
+- Ability to run tests in the target environment
+
+## Usage
+
+To use this workflow:
+
+1. Configure the target pattern in `workflow.yml` to match the RSpec files you want to convert (or pass in via CLI --target option):
+   ```yaml
+   target: "path/to/specs/**/*_spec.rb"
+   ```
+
+2. Run the workflow with:
+   ```
+   roast execute examples/rspec_to_minitest/workflow.yml
+   ```
+
+3. Review the generated Minitest files and ensure they're correctly placed in your test directory.
+
+## Implementation Details
+
+The workflow leverages the following tools:
+
+- Standard file operations (read/write)
+- Code search capabilities to find related files
+- Command execution to run tests
+- CodingAgent for iterative improvements using AI-powered coding assistance
+
+## Required Tool: CodingAgent
+
+This workflow introduces a new tool called `CodingAgent` which leverages Claude Code to perform code-related tasks:
+
+1. Running tests
+2. Analyzing errors and failures
+3. Making iterative improvements to code
+
+The CodingAgent tool is implemented in `lib/roast/tools/coding_agent.rb`.
+
+## Conversion Mappings
+
+The workflow handles these common RSpec to Minitest conversions:
+
+| RSpec Feature | Minitest Equivalent |
+|---------------|---------------------|
+| `describe/context` | Test class |
+| `it` blocks | `test_*` methods |
+| `before/after` | `setup/teardown` methods |
+| `let/let!` | Instance variables or helper methods |
+| `expect(x).to eq(y)` | `assert_equal y, x` |
+| `expect(x).to be_truthy` | `assert x` |
+| `expect(x).to be_falsey` | `refute x` |
+| `expect { ... }.to raise_error` | `assert_raises { ... }` |
+| Mocks/doubles | Minitest mocking or Mocha |

data/examples/rspec_to_minitest/analyze_spec/prompt.md

@@ -0,0 +1,30 @@
+In this first step, try to understand the purpose and dependencies of the spec we will be migrating.
+
+1. Read the provided RSpec file carefully to understand:
+   - The purpose of the test suite
+   - The subject under test (SUT)
+   - Test structure and organization 
+   - Dependencies and fixtures used
+   - Mocks, stubs, and doubles
+
+2. Use your tools to search for the SUT implementation and any other important dependent files so that they will be in the context for future steps in this process.
+   - Dependencies include fixtures
+   - Note that test/fixtures already has quite a bit of fixture files present
+   - If any fixtures are missing, copy them over when you write the new test file later
+
+3. Identify RSpec-specific features being used, such as:
+   - describe/context blocks
+   - before/after hooks
+   - let and let! declarations
+   - expect(...).to syntax and matchers
+   - shared examples/contexts
+   - metadata and tags
+
+4. Provide a summary of your analysis, including:
+   - Purpose of the test suite
+   - Main subject under test
+   - Key dependencies
+   - Testing patterns used
+   - Any potentially challenging aspects for Minitest conversion
+
+This analysis will guide the next steps of creating an equivalent Minitest implementation. 

data/examples/rspec_to_minitest/create_minitest/prompt.md

@@ -0,0 +1,33 @@
+You are a Ruby testing expert assisting with migrating RSpec tests to Minitest.
+
+In this step, you'll create a new Minitest file that replicates the functionality of the analyzed RSpec test.
+
+## Your tasks:
+
+1. Convert the RSpec test to an equivalent Minitest test, following these guidelines:
+   - Replace RSpec's `describe`/`context` blocks with Minitest test classes
+   - Convert `it` blocks to Minitest test methods (prefixed with `test_`)
+   - Transform `before`/`after` hooks to `setup`/`teardown` methods
+   - Replace `let`/`let!` declarations with instance variables or helper methods
+   - Convert `expect(...).to` assertions to Minitest assertions
+   - Replace RSpec matchers with equivalent Minitest assertions
+   - Handle mocks and stubs using Minitest's mocking capabilities and Mocha
+
+2. Follow Minitest conventions:
+   - Name the file with `_test.rb` suffix instead of `_spec.rb`
+   - Create a class that inherits from `ActiveSupport::TestCase`
+   - Use that class's `test "description of the test` method to declare tests kind of like RSpec does
+   - Use Minitest's assertion methods (`assert`, `assert_equal`, etc.)
+   - Implement proper setup and teardown methods as needed
+
+3. Pay attention to:
+   - Maintaining test coverage with equivalent assertions
+   - Preserving the original test's intent and behavior
+   - Handling RSpec-specific features appropriately
+   - Adding necessary require statements for Minitest and dependencies
+
+4. Write the complete Minitest file and save it to the appropriate location, replacing `_spec.rb` with `_test.rb` in the filename.
+
+Your converted Minitest file should maintain at least the same test coverage and intent as the original RSpec test while following Minitest's conventions and patterns.
+
+IMPORTANT: If you see opportunities to improve the test coverage in the newly written tests, you have my permission to do so. However, note that we should focus on testing behavior, not implementation. Do not test private methods, and never use Ruby tricks to make private methods public. Try to avoid mocking or stubbing anything on the SUT class.

data/examples/rspec_to_minitest/run_and_improve/prompt.md

@@ -0,0 +1,35 @@
+You are a Ruby testing expert assisting with migrating RSpec tests to Minitest.
+
+In this final step, you'll use the `cmd` and `coding_agent` tool functions to run the newly created Minitest file and iteratively improve it until all tests pass correctly.
+
+## Your tasks:
+
+1. Run the converted Minitest file to see if it passes all tests. Use the `cmd` tool function to execute the test using the following syntax:
+   ```ruby
+   ruby -Ilib:test path/to/minitest_file.rb
+   ```
+
+2. Analyze any failures or errors that occur during test execution:
+   - Syntax errors
+   - Missing dependencies
+   - Assertion failures
+   - Test setup/teardown issues
+   - Unexpected behavior
+
+3. For each issue identified, prompt the `coding_agent` tool to make necessary improvements:
+   - Fix syntax errors
+   - Correct assertion formats
+   - Add missing dependencies
+   - Adjust test setup or teardown
+   - Modify assertions to match expected behavior
+
+4. Run the test again after each set of improvements.
+
+5. Continue this iterative process until all tests pass successfully.
+
+6. Once all tests pass, provide a summary of:
+   - Changes made to fix issues
+   - Any remaining considerations or edge cases
+   - Confirmation of test coverage compared to original RSpec tests
+
+Again, your goal is to ensure the Minitest version provides at least the same test coverage and reliability as the original RSpec tests, while following Minitest best practices and conventions.

data/examples/rspec_to_minitest/workflow.md

@@ -0,0 +1,10 @@
+You are a Ruby testing expert assisting with migrating RSpec tests to Minitest. Note that all of your responses should be in nicely formatted markdown.
+
+Here is the spec we're going to be migrating today:
+
+```
+# <%= file %>
+<%= File.read(file) %>
+```
+
+I have given you powerful tool functions to do this work. The coding_agent is especially powerful and you should delegate complex tasks to it whenever possible.

data/examples/rspec_to_minitest/workflow.yml

@@ -0,0 +1,40 @@
+# RSpec to Minitest Migration Workflow
+
+# This workflow demonstrates how to convert RSpec test files to Minitest:
+# 1. Analyzes the RSpec test to understand its purpose and dependencies
+# 2. Creates a new Minitest file with equivalent assertions and test structure
+# 3. Runs the tests and makes improvements until they pass
+
+name: RSpec to Minitest Migration
+model: gpt-4.1
+
+# Target expects a glob pattern matching RSpec files to be converted
+# target: "**/*_spec.rb"
+
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::WriteFile
+  - Roast::Tools::Grep
+  - Roast::Tools::Cmd
+  - Roast::Tools::CodingAgent
+
+steps:
+  - analyze_spec
+  - create_minitest
+  - run_and_improve
+  - rubocop: $(bundle exec rubocop -A)
+  - Summarize the changes made to the codebase.
+
+# Configure the steps
+analyze_spec:
+  print_response: false
+
+create_minitest:
+  print_response: true
+
+run_and_improve:
+  print_response: true 
+
+functions:
+  grep:
+    cache: true

data/lib/roast/helpers/function_caching_interceptor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support"
+require "active_support/isolated_execution_state"
 require "active_support/cache"
 require "active_support/notifications"
 require_relative "logger"
@@ -10,17 +12,79 @@ module Roast
     # This module wraps around Raix::FunctionDispatch to provide caching for tool functions
     module FunctionCachingInterceptor
       def dispatch_tool_function(function_name, params)
-        # legacy workflows don't have a configuration
-        return super(function_name, params) if configuration.blank?
+        start_time = Time.now
 
-        function_config = configuration.function_config(function_name)
-        if function_config&.dig("cache", "enabled")
-          # Call the original function and pass in the cache
-          super(function_name, params, cache: Roast::Tools::CACHE)
-        else
-          Roast::Helpers::Logger.debug("⚠️ Caching not enabled for #{function_name}")
+        ActiveSupport::Notifications.instrument("roast.tool.execute", {
+          function_name: function_name,
+          params: params,
+        })
+
+        # Handle workflows with or without configuration
+        result = if !respond_to?(:configuration) || configuration.nil?
           super(function_name, params)
+        else
+          function_config = if configuration.respond_to?(:function_config)
+            configuration.function_config(function_name)
+          else
+            {}
+          end
+
+          # Check if caching is enabled - handle both formats:
+          # 1. cache: true (boolean format)
+          # 2. cache: { enabled: true } (hash format)
+          cache_enabled = if function_config.is_a?(Hash)
+            cache_config = function_config["cache"]
+            if cache_config.is_a?(Hash)
+              cache_config["enabled"]
+            else
+              # Direct boolean value
+              cache_config
+            end
+          else
+            false
+          end
+
+          if cache_enabled
+            # Call the original function and pass in the cache
+            super(function_name, params, cache: Roast::Tools::CACHE)
+          else
+            Roast::Helpers::Logger.debug("⚠️ Caching not enabled for #{function_name}")
+            super(function_name, params)
+          end
+        end
+
+        execution_time = Time.now - start_time
+
+        # Determine if caching was enabled for metrics
+        cache_enabled = if defined?(function_config) && function_config.is_a?(Hash)
+          cache_config = function_config["cache"]
+          if cache_config.is_a?(Hash)
+            cache_config["enabled"]
+          else
+            # Direct boolean value
+            cache_config
+          end
+        else
+          false
         end
+
+        ActiveSupport::Notifications.instrument("roast.tool.complete", {
+          function_name: function_name,
+          execution_time: execution_time,
+          cache_enabled: cache_enabled,
+        })
+
+        result
+      rescue => e
+        execution_time = Time.now - start_time
+
+        ActiveSupport::Notifications.instrument("roast.tool.error", {
+          function_name: function_name,
+          error: e.class.name,
+          message: e.message,
+          execution_time: execution_time,
+        })
+        raise
       end
     end
   end

data/lib/roast/helpers/prompt_loader.rb

@@ -74,6 +74,8 @@ module Roast
       end
 
       def extract_file_extensions
+        return [] if target_file.nil?
+
         file_basename = File.basename(target_file)
 
         if file_basename.end_with?(".md") && file_basename.count(".") > 1

data/lib/roast/resources/api_resource.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Roast
+  module Resources
+    # Resource implementation for API endpoints using Fetch API-style format
+    class ApiResource < BaseResource
+      def process
+        # For API resources, the target might be a JSON configuration or endpoint URL
+        target
+      end
+
+      def config
+        return @config if defined?(@config)
+
+        @config = if target.is_a?(String) && target.match?(/^\s*{/)
+          begin
+            JSON.parse(target)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+
+      def api_url
+        if config && config["url"]
+          config["url"]
+        else
+          # Assume direct URL
+          target
+        end
+      end
+
+      def options
+        return {} unless config
+
+        config["options"] || {}
+      end
+
+      def http_method
+        method_name = (options["method"] || "GET").upcase
+        case method_name
+        when "GET" then Net::HTTP::Get
+        when "POST" then Net::HTTP::Post
+        when "PUT" then Net::HTTP::Put
+        when "DELETE" then Net::HTTP::Delete
+        when "PATCH" then Net::HTTP::Patch
+        when "HEAD" then Net::HTTP::Head
+        else Net::HTTP::Get
+        end
+      end
+
+      def exists?
+        return false unless target
+
+        uri = URI.parse(api_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+
+        # Use HEAD request to check existence
+        request = Net::HTTP::Head.new(uri.path.empty? ? "/" : uri.path)
+
+        # Add headers if present in options
+        if options["headers"].is_a?(Hash)
+          options["headers"].each do |key, value|
+            # Process any environment variables in header values
+            processed_value = process_env_vars(value.to_s)
+            request[key] = processed_value
+          end
+        end
+
+        # Make the request
+        response = http.request(request)
+
+        # Consider 2xx and 3xx as success
+        response.code.to_i < 400
+      rescue StandardError => e
+        # Log the error but don't crash
+        Roast::Helpers::Logger.error("Error checking API existence: #{e.message}")
+        false
+      end
+
+      def contents
+        return unless target
+
+        # If it's a configuration, return a prepared request object
+        if config
+          JSON.pretty_generate({
+            "url" => api_url,
+            "method" => (options["method"] || "GET").upcase,
+            "headers" => options["headers"] || {},
+            "body" => options["body"],
+          })
+        else
+          # Assume it's a direct API URL, do a simple GET
+          begin
+            uri = URI.parse(target)
+            Net::HTTP.get(uri)
+          rescue StandardError => e
+            # Log the error but don't crash
+            Roast::Helpers::Logger.error("Error fetching API contents: #{e.message}")
+            nil
+          end
+        end
+      end
+
+      def name
+        if target
+          if config && config["url"]
+            "API #{config["url"]} (#{(options["method"] || "GET").upcase})"
+          else
+            "API #{target}"
+          end
+        else
+          "Unnamed API"
+        end
+      end
+
+      def type
+        :api
+      end
+
+      private
+
+      # Replace environment variables in the format ${VAR_NAME}
+      def process_env_vars(text)
+        text.gsub(/\${([^}]+)}/) do |_match|
+          var_name = ::Regexp.last_match(1).strip
+          ENV.fetch(var_name, "${#{var_name}}")
+        end
+      end
+    end
+  end
+end

data/lib/roast/resources/base_resource.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Base class for all resource types
+    # Follows the Strategy pattern to handle different resource types in a polymorphic way
+    class BaseResource
+      attr_reader :target
+
+      # Initialize a resource with a target
+      # @param target [String] The target specified in the workflow, can be nil
+      def initialize(target)
+        @target = target
+      end
+
+      # Process the resource to prepare it for use
+      # @return [String] The processed target
+      def process
+        target
+      end
+
+      # Check if the resource exists
+      # @return [Boolean] true if the resource exists
+      def exists?
+        false # Override in subclasses
+      end
+
+      # Get the contents of the resource
+      # @return [String] The contents of the resource
+      def contents
+        nil # Override in subclasses
+      end
+
+      # Get a name for the resource to display in logs
+      # @return [String] A descriptive name for the resource
+      def name
+        target || "Unnamed Resource"
+      end
+
+      # Get the type of this resource as a symbol
+      # @return [Symbol] The resource type
+      def type
+        :unknown
+      end
+    end
+  end
+end

data/lib/roast/resources/directory_resource.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Resource implementation for directories
+    class DirectoryResource < BaseResource
+      def process
+        if target.include?("*") || target.include?("?")
+          # If it's a glob pattern, return only directories
+          Dir.glob(target).select { |f| Dir.exist?(f) }.map { |d| File.expand_path(d) }.join("\n")
+        else
+          File.expand_path(target)
+        end
+      end
+
+      def exists?
+        Dir.exist?(target)
+      end
+
+      def contents
+        # Return a listing of files in the directory
+        if exists?
+          Dir.entries(target).reject { |f| f == "." || f == ".." }.join("\n")
+        end
+      end
+
+      def name
+        if target
+          File.basename(target) + "/"
+        else
+          "Unnamed Directory"
+        end
+      end
+
+      def type
+        :directory
+      end
+    end
+  end
+end

data/lib/roast/resources/file_resource.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Resource implementation for files
+    class FileResource < BaseResource
+      def process
+        # Handle glob patterns in the target
+        if target.include?("*") || target.include?("?")
+          Dir.glob(target).map { |f| File.expand_path(f) unless Dir.exist?(f) }.compact.join("\n")
+        else
+          File.expand_path(target)
+        end
+      end
+
+      def exists?
+        File.exist?(target) && !Dir.exist?(target)
+      end
+
+      def contents
+        File.read(target) if exists?
+      end
+
+      def name
+        File.basename(target) if target
+      end
+
+      def type
+        :file
+      end
+    end
+  end
+end

data/lib/roast/resources/none_resource.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Roast
+  module Resources
+    # Resource implementation for workflows with no target (targetless workflows)
+    class NoneResource < BaseResource
+      def process
+        nil
+      end
+
+      def exists?
+        # There's no target to check, so this is always true
+        true
+      end
+
+      def contents
+        nil
+      end
+
+      def name
+        "Targetless Resource"
+      end
+
+      def type
+        :none
+      end
+    end
+  end
+end

data/lib/roast/resources/url_resource.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Roast
+  module Resources
+    # Resource implementation for URLs
+    class UrlResource < BaseResource
+      def process
+        # URLs don't need special processing, just return as is
+        target
+      end
+
+      def exists?
+        return false unless target
+
+        begin
+          uri = URI.parse(target)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+
+          # Just check the head to see if the resource exists
+          response = http.request_head(uri.path.empty? ? "/" : uri.path)
+
+          # Consider 2xx and 3xx as success
+          response.code.to_i < 400
+        rescue StandardError => e
+          # Log the error but don't crash
+          Roast::Helpers::Logger.error("Error checking URL existence: #{e.message}")
+          false
+        end
+      end
+
+      def contents
+        return unless target
+
+        begin
+          uri = URI.parse(target)
+          Net::HTTP.get(uri)
+        rescue StandardError => e
+          # Log the error but don't crash
+          Roast::Helpers::Logger.error("Error fetching URL contents: #{e.message}")
+          nil
+        end
+      end
+
+      def name
+        if target
+          URI.parse(target).host
+        else
+          "Unnamed URL"
+        end
+      rescue URI::InvalidURIError
+        "Invalid URL"
+      end
+
+      def type
+        :url
+      end
+    end
+  end
+end