roast-ai 0.4.6 → 0.4.8

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", ...]},
-    ...
-  ]
-}
-```

data/examples/iteration/prompts/write_report.md

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

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

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

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

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

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

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

@@ -1,42 +0,0 @@
-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/json_handling/README.md

@@ -1,32 +0,0 @@
-# JSON Handling Example
-
-This example demonstrates how Roast handles JSON responses from LLM steps.
-
-## Key Features
-
-1. **JSON Arrays**: When a step has `json: true` and returns an array, the result is `flatten.first` - the first element after flattening the array. This is useful when the LLM returns an array with a single object.
-
-2. **JSON Objects**: Hash/object responses are maintained as proper Ruby hashes in the workflow output.
-
-3. **Replay Support**: JSON data structures are properly serialized and deserialized when saving/loading workflow state for replay functionality.
-
-## Running the Example
-
-```bash
-bin/roast examples/json_handling/workflow.yml
-```
-
-## How It Works
-
-1. The `fetch_users` step generates a JSON array of user objects
-2. The `fetch_metadata` step generates a JSON object with metadata
-3. The `process_data` step can access the structured data using `{{output.fetch_users}}` and `{{output.fetch_metadata}}`
-4. The structured data is preserved through the workflow, including during replay scenarios
-
-## Implementation Details
-
-When `json: true` is set on a step:
-- Array responses return `flatten.first` - the first element after flattening
-- Object responses are preserved as hashes
-- Non-JSON array responses (when `json: false`) are joined with newlines
-- The data maintains its structure when saved to and loaded from workflow state files

data/examples/json_handling/workflow.yml

@@ -1,52 +0,0 @@
-name: JSON Data Handling Example
-api_provider: openai
-model: gpt-4
-
-tools:
-  - type: write_file
-    allowed_paths:
-      - examples/json_handling/
-
-steps:
-  - name: fetch_users
-    prompt: |
-      Generate a JSON array of 3 user objects. Each user should have:
-      - id (number)
-      - name (string)
-      - email (string)
-      - active (boolean)
-    json: true
-
-  - name: fetch_metadata
-    prompt: |
-      Generate a JSON object with metadata about a dataset:
-      - total_records (number)
-      - last_updated (ISO date string)
-      - categories (array of strings)
-      - filters (object with status and sort fields)
-    json: true
-
-  - name: process_data
-    prompt: |
-      Based on the users data: {{output.fetch_users}}
-      And metadata: {{output.fetch_metadata}}
-      
-      Create a summary report describing:
-      1. How many active users there are
-      2. The categories available
-      3. When the data was last updated
-
-  - name: save_report
-    tool: write_file
-    path: examples/json_handling/report.txt
-    content: |
-      # JSON Data Processing Report
-      
-      ## Users Data
-      {{output.fetch_users}}
-      
-      ## Metadata
-      {{output.fetch_metadata}}
-      
-      ## Summary
-      {{output.process_data}}