roast-ai 0.1.7 → 0.2.0

data/examples/iteration/prompts/update_report.md

@@ -0,0 +1,29 @@
+# Update Method Count Report
+
+You are a data updater responsible for adding analysis results to a report.
+
+## Input
+- File path: {{ file_path }}
+- Method count: {{ method_count }}
+- Current report data: {{ current_report }}
+
+## Task
+1. Parse the current report data as JSON
+2. Add the new file analysis results to the report's "results" array
+3. Increment the "files_analyzed" counter by 1
+4. Add the method count to the "total_methods" counter
+5. Return the updated JSON report
+
+## Response Format
+Return a JSON object with the updated report structure:
+```json
+{
+  "files_analyzed": 10,
+  "total_methods": 45,
+  "results": [
+    {"file_path": "file1.rb", "method_count": 5, "method_names": ["method1", "method2", ...]},
+    {"file_path": "file2.rb", "method_count": 3, "method_names": ["methodA", "methodB", ...]},
+    ...
+  ]
+}
+```

data/examples/iteration/prompts/write_report.md

@@ -0,0 +1,22 @@
+# Write Method Analysis Report
+
+You are responsible for creating a formatted report file based on the analysis results.
+
+## Input
+- Report data: {{ report_data }}
+- Summary: {{ summary }}
+
+## Task
+1. Generate a Markdown report that includes:
+   - The summary information
+   - A detailed table of all files analyzed, with their method counts and method names
+2. Format the report in a clean, readable manner
+
+## Response Format
+Return a JSON object with the following structure:
+```json
+{
+  "report_content": "# Ruby Method Analysis Report\n\n{{ summary }}\n\n## Detailed Results\n\n| File | Method Count | Methods |\n|------|--------------|--------|\n| file1.rb | 5 | method1, method2, ... |\n| file2.rb | 3 | methodA, methodB, ... |\n...",
+  "report_file_path": "method_analysis_report.md"
+}
+```

data/examples/iteration/read_file/prompt.md

@@ -0,0 +1,9 @@
+I'll analyze the Ruby file at: {{current_file}}
+
+First, let me read the content of this file.
+
+```ruby
+{{read_file current_file}}
+```
+
+I'll store this content for further analysis in the next steps.

data/examples/iteration/select_next_issue/prompt.md

@@ -0,0 +1,25 @@
+I'll select the next highest priority issue to fix from our prioritized list.
+
+Here is the current prioritized list of issues:
+```json
+{{output.prioritize_issues}}
+```
+
+And here is the count of fixes we've already applied:
+```
+{{output.update_fix_count || '0'}}
+```
+
+I'll select the highest priority issue that hasn't yet been addressed. I'll consider:
+
+1. The priority score from our previous analysis
+2. Dependencies between issues (ensuring prerequisites are addressed first)
+3. Logical grouping (addressing related issues in the same file together)
+
+If there are no issues left to fix, I'll indicate this with `{"no_issues_left": true}`.
+
+For the selected issue, I'll return:
+1. The issue details
+2. The file path to modify
+3. A clear description of the changes needed
+4. Any context needed for implementation

data/examples/iteration/simple_workflow.md

@@ -0,0 +1,39 @@
+# Simple Iteration Workflow Example
+
+This example demonstrates how to use both the `each` and `repeat` iteration constructs in Roast workflows.
+
+## Workflow Description
+
+The workflow analyzes Ruby files in the `lib/roast/workflow` directory and counts the number of methods defined in each file. The process follows these steps:
+
+1. Find all Ruby files in the specified directory
+2. Initialize a report object to store our results
+3. Process each file found:
+   - Read the file content
+   - Count the methods defined
+   - Update the report with the analysis result
+4. Generate a summary report
+5. Write the report to a file
+
+## Key Components
+
+- `each` construct: Processes every Ruby file found in the directory
+- `repeat` construct: Used to generate the final summary (demonstrates a simple case of the repeat construct)
+- Both block-level and prompt-based steps
+
+## Running the Workflow
+
+To run this workflow, use the following command:
+
+```bash
+shadowenv exec -- bundle exec roast examples/iteration/simple_workflow.yml
+```
+
+The final report will be saved to a markdown file as specified in the output of the `write_report` step.
+
+## Learning Objectives
+
+- Understand how to use the `each` construct to iterate over a collection
+- Understand how to use the `repeat` construct for conditional repetition
+- Learn how to build and update data structures across workflow steps
+- See how to pass data between steps in an iteration workflow

data/examples/iteration/simple_workflow.yml

@@ -0,0 +1,58 @@
+name: Ruby Method Counter
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::Grep
+  - Roast::Tools::WriteFile
+  - Roast::Tools::CodingAgent
+
+steps:
+  # Find all Ruby files in the specified directory
+  - find_ruby_files:
+      $(find lib/roast/workflow -type f -name "*.rb")
+
+  # Initialize a report object to store our results
+  - initialize_report:
+      $(echo '{"files_analyzed": 0, "total_methods": 0, "results": []}')
+
+  # Process each file found
+  - each: "{{output['find_ruby_files'].split('\n')}}"
+    as: "current_file"
+    steps:
+      # Read the file content
+      - read_file:
+          prompt: examples/iteration/prompts/analyze_file
+          model: claude-3-haiku-20240307
+          vars:
+            file_path: "{{ current_file }}"
+
+      # Update the report with the analysis result
+      - update_report:
+          prompt: examples/iteration/prompts/update_report
+          model: claude-3-haiku-20240307
+          vars:
+            file_path: "{{ current_file }}"
+            method_count: "{{ output['read_file']['method_count'] }}"
+            current_report: "{{ output['initialize_report'] }}"
+
+  # Generate the summary report after processing all files
+  - report_count:
+      $(echo "{{ output.initialize_report.files_analyzed }}")
+
+  # Repeat to generate the final summary - demonstrates the repeat construct
+  - repeat:
+      steps:
+        - generate_summary:
+            prompt: examples/iteration/prompts/generate_summary
+            model: claude-3-haiku-20240307
+            vars:
+              report_data: "{{ output['initialize_report'] }}"
+      until: "{{true}}"
+      max_iterations: 1
+
+  # Write the report to a file
+  - write_report:
+      prompt: examples/iteration/prompts/write_report
+      model: claude-3-haiku-20240307
+      vars:
+        report_data: "{{ output['initialize_report'] }}"
+        summary: "{{ output['generate_summary']['summary'] }}"

data/examples/iteration/update_fix_count/prompt.md

@@ -0,0 +1,26 @@
+I'll update the count of fixes that have been successfully applied.
+
+Current fix count: 
+```
+{{output.update_fix_count || 0}}
+```
+
+Verification result from the previous step:
+```json
+{{output.verify_fix}}
+```
+
+I'll increment the fix count if the verification was successful or partial, but not if it failed.
+
+```javascript
+let currentCount = parseInt({{output.update_fix_count || 0}});
+let verificationStatus = "{{output.verify_fix.status}}";
+
+if (verificationStatus === "success" || verificationStatus === "partial") {
+  currentCount += 1;
+}
+
+return { fixes_applied: currentCount };
+```
+
+This updated count will be used to determine whether we've met our target for the number of fixes to implement.

data/examples/iteration/verify_fix/prompt.md

@@ -0,0 +1,29 @@
+I'll verify that the fix implemented in the previous step correctly addresses the identified issue.
+
+Here are the details of the issue that was fixed:
+```json
+{{output.select_next_issue}}
+```
+
+And here is the implementation of the fix:
+```json
+{{output.implement_fix}}
+```
+
+Now I'll read the updated file to verify the changes:
+```ruby
+{{read_file(output.select_next_issue.file_path)}}
+```
+
+I'll evaluate the fix based on these criteria:
+1. Does it fully address the identified issue?
+2. Did it introduce any new issues or regressions?
+3. Does it maintain the original functionality?
+4. Does it follow Ruby best practices and style conventions?
+5. Is it minimal and focused (changing only what was necessary)?
+
+Based on this evaluation, I'll provide:
+1. A verification status (success, partial, failure)
+2. Detailed reasoning for the status
+3. Any recommendations for further improvements or adjustments
+4. An overall assessment of the code quality improvement 

data/examples/iteration/workflow.yml

@@ -0,0 +1,42 @@
+name: Code Quality Analyzer
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::Grep
+  - Roast::Tools::WriteFile
+  - Roast::Tools::UpdateFiles
+  - Roast::Tools::CodingAgent
+  - Roast::Tools::Cmd
+
+steps:
+  # Get all Ruby files from the target directory
+  - get_files_to_analyze:
+      $(find {{resource.target}} -name "*.rb" -not -path "*/vendor/*" | grep -v "test")
+
+  # Analyze each file and generate improvement recommendations
+  - each: "{{output['get_files_to_analyze'].split('\n')}}"
+    as: "current_file"
+    steps:
+      - read_file:
+          $(cat {{current_file}})
+      - analyze_complexity
+      - generate_recommendations
+
+  # After analyzing all files, sort issues by priority
+  - prioritize_issues
+  
+  # Process the highest priority issues first, until we've addressed a sufficient number
+  # or reached our iteration limit
+  - initialize_fixes:
+      $(echo "0")
+  
+  - repeat:
+      steps:
+        - select_next_issue
+        - implement_fix
+        - verify_fix
+        - update_fix_count
+      until: "{{output['update_fix_count']['fixes_applied'] >= 5 || output['select_next_issue']['no_issues_left'] == true}}"
+      max_iterations: 10
+  
+  # Generate a summary report of all changes made
+  - generate_report

data/examples/openrouter_example/workflow.yml

@@ -1,7 +1,7 @@
 name: OpenRouter Example
 api_provider: openrouter
 api_token: $(echo $OPENROUTER_API_KEY)
-model: anthropic/claude-3-haiku-20240307
+model: google/gemini-2.0-flash-001
 
 tools:
   - Roast::Tools::ReadFile
@@ -9,4 +9,4 @@ tools:
 
 steps:
   - analyze_input
-  - generate_response
+  - generate_response

data/examples/workflow_generator/README.md

@@ -0,0 +1,27 @@
+# Workflow Generator
+
+This workflow generates new Roast workflows based on user descriptions. It's the engine behind the "New from prompt" option in `roast init`.
+
+## How It Works
+
+The workflow generator takes a user description and workflow name, then:
+
+1. **Analyzes the request** - Understands what type of workflow is needed, what steps are required, and what tools should be used
+2. **Generates structure** - Creates a complete workflow configuration including YAML and step prompts
+3. **Creates files** - Writes all the necessary files and directories to disk
+
+## Usage
+
+This workflow is typically invoked automatically by the `roast init` command, but can also be run directly:
+
+```bash
+# Run the generator workflow
+roast execute examples/workflow_generator/workflow.yml
+```
+
+## Generated Output
+
+The workflow creates a new directory with:
+- `workflow.yml` - Main workflow configuration
+- `step_name/prompt.md` - Individual step prompts
+- `README.md` - Documentation for the generated workflow

data/examples/workflow_generator/analyze_user_request/prompt.md

@@ -0,0 +1,34 @@
+You are an assistant that analyzes user requests to understand what kind of workflow they want to create.
+
+Based on the user input from the previous step:
+<%= workflow.output["get_user_input"] %>
+
+Roast information from previous step:
+<%= workflow.output["info_from_roast"] %>
+
+First, explore existing workflow examples in the examples directory to understand common patterns and structures. Look for ones that may be related to the user's intention.
+
+Then analyze the user's request and determine:
+
+1. **Required Steps**: Break down the workflow into logical steps. Each step should be a discrete task that can be accomplished with an AI prompt.
+
+2. **Tools Needed**: What Roast tools will be needed? Base this on the actual tools you read from info provided above. 
+
+3. **Target Strategy**: Will this workflow:
+   - Process specific files (needs target configuration)
+   - Be targetless (works without specific input files)
+   - Use shell commands to find targets dynamically
+
+4. **Model Requirements**: Should this use a specific model, or is the default (gpt-4o-mini) sufficient?
+
+Respond with a structured analysis in this format:
+
+```
+STEPS: [list of 3-5 logical steps]
+TOOLS: [list of required tools]
+TARGET_STRATEGY: [targetless/files/dynamic]
+MODEL: [model recommendation]
+COMPLEXITY: [simple/moderate/complex]
+```
+
+Be specific and actionable in your analysis.

data/examples/workflow_generator/create_workflow_files/prompt.md

@@ -0,0 +1,32 @@
+You are an assistant that creates the actual workflow files in the filesystem.
+
+Based on the user input:
+<%= workflow.output["get_user_input"] %>
+
+And the generated workflow structure from the previous step:
+<%= workflow.output["analyze_user_request"] %>
+
+And info from roast:
+<%= workflow.output["info_from_roast"] %>
+
+Your task is to create all the necessary files and directories for the workflow.
+
+Extract the workflow name from the user input JSON and create the workflow in the current directory under that folder name.
+
+Steps to complete:
+
+1. **Create the main directory**: Use Cmd to create the "{{ workflow_name }}" directory
+2. **Create step directories**: Create subdirectories for each workflow step  
+3. **Create workflow.yml**: Write the main workflow configuration file
+4. **Create step prompt files**: Write each step's prompt.md file
+5. **Create README.md**: Generate a helpful README explaining the workflow
+
+When writing files, extract the content from the structured response and write each file separately.
+
+Important notes:
+- Make sure all directories exist before writing files to them
+- Follow the exact structure specified in the previous step
+- Include helpful comments in the workflow.yml file
+- Make the README.md informative and include usage instructions
+
+At the end, confirm that all files have been created by listing the directory structure.

data/examples/workflow_generator/get_user_input/prompt.md

@@ -0,0 +1,14 @@
+You need to collect user input for generating a new workflow.
+
+Step 1: Ask for the workflow description using ask_user tool with prompt: "What should your workflow do?"
+
+Step 2: Ask for the workflow name using ask_user tool with prompt: "Enter workflow directory name:"
+
+Step 3: Return the result in JSON format:
+
+<json>
+{
+  "user_description": "what the user wants the workflow to do", 
+  "workflow_name": "directory_name_provided_by_user"
+}
+</json>

data/examples/workflow_generator/info_from_roast.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class InfoFromRoast < Roast::Workflow::BaseStep
+  def call
+    examples_path = File.join(Roast::ROOT, "examples")
+    tools_path = File.join(Roast::ROOT, "lib", "roast", "tools")
+
+    # Get list of available tools
+    available_tools = Dir.entries(tools_path)
+      .select { |file| file.end_with?(".rb") }
+      .map { |file| file.gsub(".rb", "") }
+      .reject { |tool| tool == "." || tool == ".." }
+      .sort
+
+    {
+      examples_directory: examples_path,
+      tools_directory: tools_path,
+      available_tools: available_tools,
+      message: "Examples directory and available tools provided for analysis step",
+    }
+  end
+end

data/examples/workflow_generator/workflow.yml

@@ -0,0 +1,35 @@
+# Workflow Generator
+#
+# This workflow generates new Roast workflows based on user descriptions.
+# It gets user input, analyzes the request, generates an appropriate workflow structure,
+# and creates all necessary files in a new directory.
+
+name: Workflow Generator
+model: gpt-4o-mini
+
+tools:
+  - Roast::Tools::WriteFile
+  - Roast::Tools::ReadFile
+  - Roast::Tools::Cmd
+  - Roast::Tools::AskUser
+
+steps:
+  - get_user_input
+  - info_from_roast
+  - analyze_user_request
+  - create_workflow_files
+
+# Step configurations
+get_user_input:
+  print_response: false
+  json: true
+  auto_loop: false
+
+analyze_user_request:
+  print_response: true
+
+generate_workflow_structure:
+  print_response: true
+
+create_workflow_files:
+  print_response: false

data/lib/roast/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Roast
+  # Custom error for API resource not found (404) responses
+  class ResourceNotFoundError < StandardError; end
+
+  # Custom error for when API authentication fails
+  class AuthenticationError < StandardError; end
+end

data/lib/roast/factories/api_provider_factory.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Roast
+  module Factories
+    # Factory for determining and creating API provider configurations
+    class ApiProviderFactory
+      SUPPORTED_PROVIDERS = {
+        "openai" => :openai,
+        "openrouter" => :openrouter,
+      }.freeze
+
+      DEFAULT_PROVIDER = :openai
+
+      class << self
+        # Determines the API provider from configuration
+        # @param config [Hash] The configuration hash
+        # @return [Symbol] The API provider symbol (:openai or :openrouter)
+        def from_config(config)
+          return DEFAULT_PROVIDER unless config["api_provider"]
+
+          provider_name = config["api_provider"].to_s.downcase
+          provider = SUPPORTED_PROVIDERS[provider_name]
+
+          unless provider
+            Roast::Helpers::Logger.warn("Unknown API provider '#{provider_name}', defaulting to #{DEFAULT_PROVIDER}")
+            return DEFAULT_PROVIDER
+          end
+
+          provider
+        end
+
+        # Returns true if the provider is OpenRouter
+        # @param provider [Symbol] The provider symbol
+        # @return [Boolean]
+        def openrouter?(provider)
+          provider == :openrouter
+        end
+
+        # Returns true if the provider is OpenAI
+        # @param provider [Symbol] The provider symbol
+        # @return [Boolean]
+        def openai?(provider)
+          provider == :openai
+        end
+
+        # Returns the list of supported provider names
+        # @return [Array<String>]
+        def supported_provider_names
+          SUPPORTED_PROVIDERS.keys
+        end
+
+        # Validates a provider symbol
+        # @param provider [Symbol] The provider to validate
+        # @return [Boolean]
+        def valid_provider?(provider)
+          SUPPORTED_PROVIDERS.values.include?(provider)
+        end
+      end
+    end
+  end
+end

data/lib/roast/helpers/function_caching_interceptor.rb

@@ -4,7 +4,7 @@ require "active_support"
 require "active_support/isolated_execution_state"
 require "active_support/cache"
 require "active_support/notifications"
-require_relative "logger"
+require "roast/helpers/logger"
 
 module Roast
   module Helpers

data/lib/roast/helpers/minitest_coverage_runner.rb

@@ -2,7 +2,7 @@
 
 require "coverage"
 require "minitest"
-require_relative "logger"
+require "roast/helpers/logger"
 
 # Disable the built-in `at_exit` hook for Minitest before anything else
 module Minitest

data/lib/roast/helpers/prompt_loader.rb

@@ -89,11 +89,60 @@ module Roast
 
       def process_erb_if_needed(content)
         if content.include?("<%")
-          ERB.new(content, trim_mode: "-").result(context.instance_eval { binding })
+          begin
+            ERB.new(content, trim_mode: "-").result(context.instance_eval { binding })
+          rescue TypeError => e
+            if e.message.include?("no implicit conversion of nil into String")
+              # Try to find which variable is causing the issue
+              variable_hint = detect_nil_variable(content)
+
+              error_message = <<~ERROR
+                This workflow requires a file or target to be specified.
+                #{variable_hint}
+
+                Usage: roast execute <workflow.yml> <file_or_pattern>
+
+                Examples:
+                  roast execute #{context.respond_to?(:configuration) && context.configuration&.workflow_path || "workflow.yml"} test/my_test.rb
+                  roast execute #{context.respond_to?(:configuration) && context.configuration&.workflow_path || "workflow.yml"} "test/**/*_test.rb"
+              ERROR
+              raise error_message
+            else
+              raise e
+            end
+          rescue NoMethodError => e
+            if e.message.include?("undefined method") && e.message.include?("for nil")
+              variable_hint = detect_nil_variable(content)
+
+              error_message = <<~ERROR
+                Error processing prompt template: #{e.message}
+                #{variable_hint}
+
+                This may indicate that the workflow requires a file or target to be specified.
+
+                Usage: roast execute <workflow.yml> <file_or_pattern>
+              ERROR
+              raise error_message
+            else
+              raise e
+            end
+          end
         else
           content
         end
       end
+
+      def detect_nil_variable(content)
+        if content.include?("workflow.file")
+          "The prompt template references 'workflow.file' but no file was provided."
+        elsif content.include?("<%= file %>")
+          "The prompt template references 'file' but no file was provided."
+        elsif content.match(/<%= .*?\.(\w+) %>/)
+          "The prompt template is trying to access a property that doesn't exist."
+        else
+          "The prompt template contains an ERB expression that references a nil value."
+        end
+      end
     end
   end
 end

data/lib/roast/resources/base_resource.rb

@@ -19,6 +19,13 @@ module Roast
         target
       end
 
+      # Get the value of the resource (alias for target)
+      # Used for backward compatibility
+      # @return [String] The resource target value
+      def value
+        target
+      end
+
       # Check if the resource exists
       # @return [Boolean] true if the resource exists
       def exists?

data/lib/roast/resources.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "resources/base_resource"
-require_relative "resources/file_resource"
-require_relative "resources/directory_resource"
-require_relative "resources/url_resource"
-require_relative "resources/api_resource"
-require_relative "resources/none_resource"
+require "roast/resources/base_resource"
+require "roast/resources/file_resource"
+require "roast/resources/directory_resource"
+require "roast/resources/url_resource"
+require "roast/resources/api_resource"
+require "roast/resources/none_resource"
 require "uri"
 
 module Roast