roast-ai 0.1.7 → 0.2.0

data/examples/conditional/simple_workflow.yml

@@ -0,0 +1,15 @@
+name: Simple Conditional Test
+tools: []
+
+steps:
+  - set_value: "$(echo 'true')"
+  
+  - if: "{{output.set_value.strip == 'true'}}"
+    then:
+      - success: "$(echo 'If condition worked!')"
+    else:
+      - failure: "$(echo 'If condition failed!')"
+  
+  - unless: "{{output.set_value.strip == 'false'}}"
+    then:
+      - unless_success: "$(echo 'Unless condition worked!')"

data/examples/conditional/workflow.yml

@@ -0,0 +1,23 @@
+name: Conditional Execution Example
+tools:
+  - Roast::Tools::Cmd
+
+steps:
+  - check_os: "$(uname -s)"
+  
+  - if: "{{output.check_os.strip == 'Darwin'}}"
+    then:
+      - mac_message: "$(echo 'Running on macOS!')"
+      - mac_info: "$(sw_vers)"
+    else:
+      - linux_message: "$(echo 'Running on Linux!')"
+      - linux_info: "$(lsb_release -a)"
+  
+  - check_file: "$(test -f /tmp/roast_test.txt && echo exists || echo missing)"
+  
+  - unless: "{{output.check_file.strip == 'exists'}}"
+    then:
+      - create_file: "$(touch /tmp/roast_test.txt && echo 'File created')"
+  
+  - verify_file: "$(ls -la /tmp/roast_test.txt)"
+  - cleanup: "$(rm -f /tmp/roast_test.txt)"

data/examples/dot_notation/README.md

@@ -0,0 +1,37 @@
+# Dot Notation Access Example
+
+This example demonstrates the new dot notation access feature for workflow outputs.
+
+## Usage
+
+With the new dot notation feature, you can access output values using Ruby's method syntax instead of hash syntax:
+
+### Before (hash syntax):
+```yaml
+until: "output[:update_fix_count][:fixes_applied] >= 5 || output[:select_next_issue][:no_issues_left] == true"
+```
+
+### After (dot notation):
+```yaml
+until: "output.update_fix_count.fixes_applied >= 5 || output.select_next_issue.no_issues_left?"
+```
+
+### Even cleaner (omitting output prefix):
+```yaml
+until: "update_fix_count.fixes_applied >= 5 || select_next_issue.no_issues_left?"
+```
+
+## Features
+
+1. **Nested access**: `output.step_name.nested.value`
+2. **Boolean predicates**: `output.step_name.is_complete?` returns false for nil/false values
+3. **Direct access**: Omit the `output.` prefix for cleaner syntax
+4. **Backward compatible**: Hash syntax still works (`output[:step_name][:value]`)
+
+## Example Workflow
+
+See `workflow.yml` for a complete example that demonstrates:
+- Setting values in output
+- Using dot notation in conditions
+- Boolean predicate methods
+- Nested value access

data/examples/dot_notation/workflow.yml

@@ -0,0 +1,44 @@
+name: dot_notation_example
+description: Example demonstrating dot notation access for workflow outputs
+
+steps:
+  initialize:
+    prompt: |
+      Initialize the workflow with some sample data.
+      
+      Set output.counter to 0
+      Set output.config.max_iterations to 5
+      Set output.config.enabled to true
+
+  process_items:
+    repeat:
+      # Using dot notation in conditions
+      until: "counter >= config.max_iterations || !config.enabled?"
+      steps:
+        - increment_counter
+        - check_status
+
+  increment_counter:
+    prompt: |
+      Increment the counter by 1.
+      Current counter value: {{counter}}
+      
+      Set output.counter to {{counter}} + 1
+
+  check_status:
+    prompt: |
+      Check if we should continue processing.
+      
+      Current counter: {{counter}}
+      Max iterations: {{config.max_iterations}}
+      
+      If counter is 3, set output.config.enabled to false
+      Set output.status.last_checked to current counter value
+
+  summarize:
+    prompt: |
+      Summarize the results:
+      - Total iterations: {{counter}}
+      - Last checked at: {{status.last_checked}}
+      - Was enabled: {{config.enabled}}
+      - Hit max iterations: {{counter >= config.max_iterations ? "Yes" : "No"}}

data/examples/exit_on_error/README.md

@@ -0,0 +1,50 @@
+# Exit on Error Example
+
+This example demonstrates how to use the `exit_on_error` configuration option to continue workflow execution even when a command fails.
+
+## Use Case
+
+When running a linter like RuboCop on a file with syntax errors or style violations, the command will exit with a non-zero status. By default, this would halt the workflow. However, we often want to:
+
+1. Capture the linter output (including errors)
+2. Analyze what went wrong
+3. Apply fixes based on the analysis
+
+## Configuration
+
+The key configuration is in the step configuration section:
+
+```yaml
+lint_check:
+  exit_on_error: false
+```
+
+This tells Roast to:
+- Continue workflow execution even if the command fails
+- Capture the full output (stdout and stderr)
+- Append the exit status to the output
+
+## Output Format
+
+When a command fails with `exit_on_error: false`, the output will look like:
+
+```
+lib/example.rb:5:3: C: Style/StringLiterals: Prefer double-quoted strings
+  'hello'
+  ^^^^^^^
+[Exit status: 1]
+```
+
+This allows subsequent steps to process both the error output and the exit status.
+
+## Running the Example
+
+```bash
+roast execute workflow.yml path/to/file.rb
+```
+
+The workflow will:
+1. Run RuboCop on the file
+2. Continue even if RuboCop finds issues
+3. Analyze the linter output
+4. Apply fixes based on the analysis

data/examples/exit_on_error/analyze_lint_output/prompt.md

@@ -0,0 +1,9 @@
+The linter output from the previous step shows issues with the code.
+Please analyze the output and identify the specific problems that need to be fixed.
+
+Focus on:
+- Syntax errors
+- Style violations
+- Best practice violations
+
+Provide a structured list of issues found.

data/examples/exit_on_error/apply_fixes/prompt.md

@@ -0,0 +1,2 @@
+Based on the analysis, please generate the fixes for the identified issues.
+Use the CodingAgent tool to apply the necessary changes to the file.

data/examples/exit_on_error/workflow.yml

@@ -0,0 +1,19 @@
+name: Linting with Error Recovery
+tools:
+  - Roast::Tools::ReadFile
+  - Roast::Tools::WriteFile
+  - Roast::Tools::CodingAgent
+
+steps:
+  # Run linter on the file - may fail if there are syntax errors
+  - lint_check: $(rubocop {{file}})
+  
+  # Analyze linter output and fix issues even if linter failed
+  - analyze_lint_output
+  
+  # Apply fixes based on the analysis
+  - apply_fixes
+
+# Step configuration
+lint_check:
+  exit_on_error: false  # Continue even if rubocop exits with non-zero status

data/examples/grading/workflow.yml

@@ -1,10 +1,12 @@
-name: Grading current test changes
+name: Test Grading
+model: anthropic:claude-opus-4
 
 tools:
   - Roast::Tools::Grep
   - Roast::Tools::ReadFile
   - Roast::Tools::SearchFile
 
+# Uncomment this to run the workflow on modified tests automatically
 # each: '% cd $(git rev-parse --show-toplevel) && git status --porcelain | grep "_test\.rb" | cut -c4- | xargs realpath'
 
 steps:
@@ -35,3 +37,5 @@ generate_recommendations:
   json: true
   params:
     max_completion_tokens: 5_000
+
+

data/examples/iteration/IMPLEMENTATION.md

@@ -0,0 +1,88 @@
+# Iteration Mechanisms Implementation
+
+This document provides an overview of how the iteration mechanisms are implemented in Roast.
+
+## Core Components
+
+### 1. Schema Extensions
+
+The workflow schema has been extended to support two new iteration constructs:
+
+- **Repeat** - For conditional repetition until a condition is met
+- **Each** - For iterating over collections with a variable binding
+
+These schema extensions define the structure and validation rules for the iteration YAML syntax.
+
+### 2. Step Classes
+
+Two new step classes handle the actual iteration logic:
+
+- **RepeatStep** - Executes steps repeatedly until a condition is met or a maximum iteration count is reached
+- **EachStep** - Iterates over a collection, binding each item to a variable, and executes steps for each item
+
+Both inherit from a common `BaseIterationStep` class that provides shared functionality.
+
+### 3. Pattern Matching
+
+The `WorkflowExecutor` has been enhanced with pattern matching to recognize the `repeat` and `each` keywords and dispatch to the appropriate step classes:
+
+```ruby
+case name
+when "repeat"
+  execute_repeat_step(command)
+when "each"
+  # Handle 'each' step with its special format
+  execute_each_step(step)
+else
+  # Handle regular steps
+end
+```
+
+### 4. State Management
+
+Both iteration types include state management to:
+
+- Track current iteration number
+- Save state after each iteration
+- Support resumption after failures
+- Provide safety limits against infinite loops
+
+## Iteration Flow
+
+### RepeatStep Flow
+
+1. Start with iteration count = 0
+2. Execute the nested steps in sequence
+3. Evaluate the until condition
+4. If condition is true or max_iterations is reached, stop
+5. Otherwise, increment iteration count and go back to step 2
+6. Return the results of all iterations
+
+### EachStep Flow
+
+1. Resolve the collection expression
+2. For each item in the collection:
+   a. Set the named variable (accessible in steps through a getter method)
+   b. Execute the nested steps
+   c. Save state
+3. Return the results from all iterations
+
+## Safety Mechanisms
+
+- **max_iterations** parameter prevents infinite loops
+- State is saved after each iteration for resumption capability
+- Robust error handling during condition evaluation and step execution
+- Collection type checking ensures iterable objects
+
+## Usage Examples
+
+The workflow.yml and step files in this directory demonstrate practical applications of these iteration mechanisms for code quality analysis.
+
+## Integration with Existing Workflow Engine
+
+The iteration mechanism integrates seamlessly with the existing workflow engine:
+
+- Uses the same state persistence mechanisms
+- Follows the same execution models
+- Maintains compatibility with all existing steps
+- Supports interpolation within iteration constructs

data/examples/iteration/README.md

@@ -0,0 +1,68 @@
+# Code Quality Analysis Workflow
+
+This example demonstrates the use of Roast's iteration features to analyze and improve code quality across a codebase.
+
+## What it does
+
+1. Collects Ruby files from the codebase for analysis
+2. Analyzes each file for complexity, code smells, and potential improvements
+3. Generates recommendations for each file
+4. Prioritizes the identified issues by impact and difficulty
+5. Automatically implements fixes for the highest-priority issues
+6. Verifies each fix before moving to the next one
+7. Continues until either 5 fixes have been applied or all issues are addressed
+8. Generates a summary report of changes made
+
+## Iteration Features Demonstrated
+
+### Collection Iteration with `each`
+
+The workflow uses the `each` construct to iterate through Ruby files:
+
+```yaml
+- each: "output['get_files_to_analyze'].split('\n')"
+  as: "current_file"
+  steps:
+    - read_file
+    - analyze_complexity
+    - generate_recommendations
+```
+
+This makes the current file available as `current_file` in each step, allowing the analysis steps to process each file individually.
+
+### Conditional Repetition with `repeat`
+
+The workflow uses the `repeat` construct to iteratively fix issues until a condition is met:
+
+```yaml
+- 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
+```
+
+This continues applying fixes until either:
+- 5 fixes have been successfully applied
+- No more issues remain to be fixed
+- The maximum of 10 iterations is reached (safety limit)
+
+## Running the Example
+
+To run this workflow:
+
+```bash
+roast run examples/iteration/workflow.yml --target=/path/to/your/project
+```
+
+The workflow will analyze the Ruby files in your project, suggest improvements, and apply the highest-priority fixes.
+
+## Customizing
+
+- Adjust the file selection criteria in `get_files_to_analyze`
+- Modify the analysis criteria in `analyze_complexity`
+- Change the fix limit in the `until` condition
+- Set a different `max_iterations` value to control the maximum number of fixes

data/examples/iteration/analyze_complexity/prompt.md

@@ -0,0 +1,22 @@
+I'll analyze the code complexity of the file {{current_file}}, which I've read in the previous step.
+
+I'll examine the following aspects:
+1. Cyclomatic complexity (number of decision paths)
+2. Method length and complexity
+3. Class size and responsibilities
+4. Code smells (long parameter lists, deeply nested blocks, etc.)
+5. Potential performance bottlenecks
+6. Opportunities for refactoring
+
+```ruby
+{{output.read_file}}
+```
+
+Based on this analysis, I'll provide a structured assessment of the code quality issues found.
+
+For each issue identified, I'll assign:
+- Severity (high, medium, low)
+- Type (complexity, maintainability, performance, style)
+- Location (line numbers, method/class names)
+- Brief description of the issue
+- Suggested improvement

data/examples/iteration/generate_recommendations/prompt.md

@@ -0,0 +1,21 @@
+Based on the analysis of complexity for file {{current_file}}, I'll generate specific recommendations for improving code quality.
+
+I'll use the complexity analysis from the previous step:
+```json
+{{output.analyze_complexity}}
+```
+
+For each identified issue, I'll provide detailed, actionable recommendations including:
+
+1. What specific changes should be made
+2. How the change improves the code
+3. Sample code snippets demonstrating the improvement
+4. An estimate of effort required (low, medium, high)
+5. Priority level for implementation
+
+I'll organize these recommendations to address:
+- Most critical issues first
+- Quick wins that provide significant value for minimal effort
+- Long-term architectural improvements
+
+My recommendations will follow Ruby best practices, adhere to common style guides, and consider maintainability, readability, and performance. 

data/examples/iteration/generate_report/prompt.md

@@ -0,0 +1,129 @@
+# Code Quality Improvement Report
+
+## Summary of Analysis and Improvements
+
+I've analyzed {{output.get_files_to_analyze.split('\n').length}} Ruby files for code quality issues and made targeted improvements.
+
+### Files Analyzed
+
+```
+{{output.get_files_to_analyze}}
+```
+
+### Issues Identified
+
+Total issues identified: {{output.prioritize_issues.total_issues}}
+
+Issues by severity:
+- High: {{output.prioritize_issues.high_severity || 0}}
+- Medium: {{output.prioritize_issues.medium_severity || 0}}
+- Low: {{output.prioritize_issues.low_severity || 0}}
+
+Issues by type:
+- Complexity: {{output.prioritize_issues.complexity_issues || 0}}
+- Maintainability: {{output.prioritize_issues.maintainability_issues || 0}}
+- Performance: {{output.prioritize_issues.performance_issues || 0}}
+- Style: {{output.prioritize_issues.style_issues || 0}}
+
+### Improvements Made
+
+Number of fixes applied: {{output.update_fix_count.fixes_applied || 0}}
+
+{{#if output.update_fix_count.fixes_applied > 0}}
+Fixes by type:
+{{#each output.fix_summary}}
+- {{this.type}}: {{this.count}} ({{this.percentage}}% of total)
+{{/each}}
+
+Top files improved:
+{{#each output.file_improvements}}
+- {{this.file}}: {{this.issues_fixed}} issues fixed
+{{/each}}
+{{else}}
+No fixes were applied during this run.
+{{/if}}
+
+## Detailed Fix List
+
+{{#if output.update_fix_count.fixes_applied > 0}}
+{{#each output.fixes_applied}}
+### Fix #{{@index + 1}}: {{this.issue.type}} in {{this.issue.file_path}}
+
+**Issue**: {{this.issue.description}}  
+**Location**: {{this.issue.location}}  
+**Severity**: {{this.issue.severity}}  
+
+**Solution Applied**: {{this.fix_description}}
+
+```diff
+{{this.diff}}
+```
+
+**Verification**: {{#if this.verification.success}}✅ Successful{{else}}❌ Failed: {{this.verification.reason}}{{/if}}
+
+{{/each}}
+{{else}}
+No fixes were applied during this run.
+{{/if}}
+
+## Recommendations for Future Improvements
+
+Based on the remaining issues, here are the top recommendations for improving code quality:
+
+{{#each output.top_recommendations}}
+{{@index + 1}}. **{{this.title}}**  
+   {{this.description}}  
+   Affected files: {{this.affected_files}}
+{{/each}}
+
+## Conclusion
+
+This automated code quality improvement run has {{#if output.update_fix_count.fixes_applied > 0}}successfully addressed {{output.update_fix_count.fixes_applied}} issues{{else}}identified issues but did not apply any fixes{{/if}}. The remaining issues should be reviewed and addressed as part of ongoing code maintenance.
+
+I'll generate a comprehensive summary report of all the code quality improvements made during this workflow.
+
+Total number of fixes applied:
+```
+{{output.update_fix_count.fixes_applied || 0}}
+```
+
+I'll analyze the following data to create the report:
+1. Original list of issues identified:
+```json
+{{output.prioritize_issues}}
+```
+
+2. Issues that were addressed:
+```json
+{{outputs_of.select_next_issue}}
+```
+
+3. Implementation and verification details:
+```json
+{{outputs_of.implement_fix}}
+{{outputs_of.verify_fix}}
+```
+
+The report will include:
+
+1. **Executive Summary**
+   - Total files analyzed
+   - Total issues identified
+   - Issues fixed vs. remaining
+   - Most common issue types
+   
+2. **Detailed Analysis by File**
+   - Issues fixed per file
+   - Before/after code quality assessment
+   
+3. **Implementation Details**
+   - Description of each fix
+   - Impact on code quality
+   - Verification results
+   
+4. **Recommendations**
+   - Remaining high-priority issues
+   - Suggested next steps
+   - Long-term code quality improvement suggestions
+
+This report provides a comprehensive overview of the code quality improvements made and serves as documentation for the changes implemented.

data/examples/iteration/implement_fix/prompt.md

@@ -0,0 +1,25 @@
+I'll implement the fix for the issue selected in the previous step.
+
+Here is the issue to fix:
+```json
+{{output.select_next_issue}}
+```
+
+First, I'll read the current file content to understand the context:
+
+```ruby
+{{read_file(output.select_next_issue.file_path)}}
+```
+
+Based on the issue description and the recommended changes, I'll implement a fix that:
+1. Addresses the specific issue identified
+2. Follows Ruby best practices and style conventions
+3. Is minimal and focused (changes only what's necessary)
+4. Maintains or improves the existing functionality
+
+I'll use the update_files tool to apply the changes. For each change, I'll provide:
+1. The file path
+2. The changes to make
+3. A detailed explanation of what was changed and why
+
+After implementing the fix, I'll return a summary of the changes made.

data/examples/iteration/prioritize_issues/prompt.md

@@ -0,0 +1,24 @@
+I'll analyze all the recommendations I've generated across multiple files and prioritize them according to:
+
+1. Severity of the issues
+2. Complexity of implementation
+3. Impact on code quality and maintainability
+4. Dependencies between issues
+
+Let me review all the recommendations collected so far:
+
+```json
+{{outputs_of.generate_recommendations}}
+```
+
+I'll create a comprehensive prioritized list of all issues across files, combining similar issues where appropriate. The prioritized list will include:
+
+1. Issue ID
+2. File path
+3. Issue description 
+4. Severity (High, Medium, Low)
+5. Implementation difficulty (Easy, Medium, Hard)
+6. Priority score (calculated from severity and difficulty)
+7. Dependencies (if any)
+
+This prioritized list will guide our approach to addressing the most important issues first, while being mindful of dependencies between issues. 

data/examples/iteration/prompts/analyze_file.md

@@ -0,0 +1,28 @@
+# Ruby File Method Analysis
+
+You are a code analyzer focusing on analyzing Ruby files to count the number of methods defined.
+
+## Input
+- File path: {{ file_path }}
+- File content:
+```ruby
+{{ tools.read_file.content(file_path) }}
+```
+
+## Task
+1. Analyze the Ruby file content
+2. Count the number of methods defined in the file (including class methods, instance methods, and module methods)
+3. Return a JSON object with:
+   - file_name: The basename of the file
+   - method_count: The number of methods found
+   - method_names: An array of method names found in the file
+
+## Response Format
+Return a JSON object with the following structure:
+```json
+{
+  "file_name": "base_step.rb",
+  "method_count": 5,
+  "method_names": ["initialize", "call", "validate", "execute", "helper_method"]
+}
+```

data/examples/iteration/prompts/generate_summary.md

@@ -0,0 +1,24 @@
+# Generate Method Analysis Summary
+
+You are a report generator responsible for summarizing the method analysis results.
+
+## Input
+- Report data: {{ report_data }}
+
+## Task
+1. Parse the report data as JSON
+2. Create a summary of the analysis results including:
+   - Total number of files analyzed
+   - Total number of methods found
+   - Average number of methods per file
+   - File with the most methods
+   - File with the fewest methods
+3. Generate a formatted summary text
+
+## Response Format
+Return a JSON object with the following structure:
+```json
+{
+  "summary": "## Ruby Method Analysis Summary\n\nAnalyzed 10 Ruby files in the workflow directory.\n- Total methods found: 45\n- Average methods per file: 4.5\n- Most methods: base_workflow.rb (12 methods)\n- Fewest methods: state_repository.rb (1 method)\n\n### Top 3 Files by Method Count\n1. base_workflow.rb: 12 methods\n2. configuration.rb: 8 methods\n3. workflow_executor.rb: 7 methods\n"
+}
+```