roast-ai 0.4.7 → 0.4.8

data/examples/interpolation/README.md

@@ -1,50 +0,0 @@
-# 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

@@ -1 +0,0 @@
-Analyze the file at: <%= workflow.file %>

data/examples/interpolation/analyze_patterns/prompt.md

@@ -1,27 +0,0 @@
-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

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

data/examples/interpolation/generate_report_for_rb/prompt.md

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

data/examples/interpolation/sample.js

@@ -1,48 +0,0 @@
-// 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

@@ -1,42 +0,0 @@
-# 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

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

data/examples/interpolation/workflow.yml

@@ -1,21 +0,0 @@
-name: interpolation_example
-model: gpt-4o-mini
-
-tools:
-  - Roast::Tools::ReadFile
-
-steps:
-  - analyze_file
-  - 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/examples/iteration/IMPLEMENTATION.md

@@ -1,88 +0,0 @@
-# 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

@@ -1,68 +0,0 @@
-# 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

@@ -1,22 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,129 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,28 +0,0 @@
-# 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
-<%= read_file(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

@@ -1,24 +0,0 @@
-# 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"
-}
-```

data/examples/iteration/prompts/update_report.md

@@ -1,29 +0,0 @@
-# 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", ...]},
-    ...
-  ]
-}
-```