roast-ai 0.4.7 → 0.4.8

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}}

data/examples/mcp/README.md

@@ -1,223 +0,0 @@
-# MCP (Model Context Protocol) Tools
-
-This example demonstrates how to use MCP tools in Roast workflows. MCP is an open standard that enables seamless integration between AI applications and external data sources and tools.
-
-## What are MCP Tools?
-
-MCP tools allow your Roast workflows to connect to external services and tools through a standardized protocol. This enables:
-
-- Access to external APIs and services
-- Integration with databases and file systems
-- Connection to specialized tools and platforms
-- Real-time data access during workflow execution
-
-## Configuration
-
-MCP tools are configured in the `tools` section of your workflow YAML file. Roast supports two types of MCP connections:
-
-### 1. SSE (Server-Sent Events) MCP Tools
-
-Connect to HTTP endpoints that implement the MCP protocol:
-
-```yaml
-tools:
-  - Tool Name:
-      url: https://example.com/mcp-endpoint
-      env:
-        - "Authorization: Bearer {{resource.api_token}}"
-      only:
-        - allowed_function_1
-        - allowed_function_2
-```
-
-### 2. Stdio MCP Tools
-
-Connect to local processes that implement the MCP protocol:
-
-```yaml
-tools:
-  - Tool Name:
-      command: docker
-      args:
-        - run
-        - -i
-        - --rm
-        - ghcr.io/example/mcp-server
-      env:
-        API_KEY: "{{ENV['API_KEY']}}"
-      except:
-        - dangerous_function
-```
-
-## Parameters
-
-- **`url`** (SSE only): The HTTP(S) endpoint URL for the MCP server
-- **`command`** (stdio only): The command to execute
-- **`args`** (stdio only): Array of command-line arguments
-- **`env`**: Headers (SSE) or environment variables (stdio)
-- **`only`**: Whitelist of functions to include
-- **`except`**: Blacklist of functions to exclude
-
-## Example Workflow
-
-The `workflow.yml` in this directory shows a simple example using GitMCP to read documentation:
-
-```yaml
-name: MCP Tools Example
-model: gpt-4o-mini
-tools:
-  - Roast Docs:
-      url: https://gitmcp.io/Shopify/roast/docs
-
-steps:
-  - get_doc: Read the Roast docs, and tell me how to use MCP tools.
-  - summarize
-
-summarize:
-  print_response: true
-```
-
-## Running the Examples
-
-### Simple Example (no authentication required)
-
-```bash
-# Run the basic MCP example
-roast execute examples/mcp/workflow.yml
-
-# Run the multi-tool example
-roast execute examples/mcp/multi_mcp_workflow.yml
-```
-
-### GitHub Example (requires GitHub token)
-
-```bash
-# Set your GitHub token first
-export GITHUB_TOKEN="your-github-personal-access-token"
-
-# Run the GitHub workflow
-roast execute examples/mcp/github_workflow.yml
-```
-
-### Filesystem Example
-
-```bash
-# This uses the filesystem MCP server to safely browse /tmp
-roast execute examples/mcp/filesystem_demo/workflow.yml
-```
-
-## More Examples
-
-### GitHub Integration
-
-```yaml
-tools:
-  - GitHub:
-      command: npx
-      args: ["-y", "@modelcontextprotocol/server-github"]
-      env:
-        GITHUB_PERSONAL_ACCESS_TOKEN: "{{ENV['GITHUB_TOKEN']}}"
-      only:
-        - search_repositories
-        - get_issue
-        - create_issue
-```
-
-### Database Access
-
-```yaml
-tools:
-  - Database:
-      command: npx
-      args: ["-y", "@modelcontextprotocol/server-postgres"]
-      env:
-        DATABASE_URL: "{{ENV['DATABASE_URL']}}"
-      only:
-        - query
-        - list_tables
-```
-
-### Using Multiple MCP Tools
-
-You can combine MCP tools with traditional Roast tools:
-
-```yaml
-tools:
-  # Traditional Roast tools
-  - Roast::Tools::ReadFile
-  - Roast::Tools::WriteFile
-  
-  # MCP tools
-  - External API:
-      url: https://api.example.com/mcp
-  - Local Tool:
-      command: ./my-mcp-server
-```
-
-## Installing and Using MCP Servers
-
-MCP servers can be run in different ways:
-
-### Using npx (recommended for testing)
-
-Most official MCP servers can be run directly with npx without installation:
-
-```bash
-# These are automatically downloaded and run when used in workflows
-npx -y @modelcontextprotocol/server-github
-npx -y @modelcontextprotocol/server-filesystem /path/to/allow
-npx -y @modelcontextprotocol/server-sqlite /path/to/database.db
-```
-
-### Installing globally
-
-For production use, you might want to install servers globally:
-
-```bash
-npm install -g @modelcontextprotocol/server-github
-npm install -g @modelcontextprotocol/server-filesystem
-```
-
-### Available MCP Servers
-
-Popular MCP servers you can use:
-
-- **@modelcontextprotocol/server-filesystem**: Safe filesystem access
-- **@modelcontextprotocol/server-github**: GitHub API integration (requires token)
-- **@modelcontextprotocol/server-gitlab**: GitLab API integration
-- **@modelcontextprotocol/server-google-drive**: Google Drive access
-- **@modelcontextprotocol/server-slack**: Slack integration
-- **@modelcontextprotocol/server-postgres**: PostgreSQL database access
-- **@modelcontextprotocol/server-sqlite**: SQLite database access
-
-For more MCP servers, visit: https://github.com/modelcontextprotocol/servers
-
-## Troubleshooting
-
-### Common Issues
-
-1. **"No such file or directory" error**
-   - Make sure `npx` is installed: `which npx`
-   - For local commands, ensure they're in your PATH
-
-2. **"Bad credentials" or authentication errors**
-   - Check that your environment variables are set correctly
-   - Use `{{ENV['VAR_NAME']}}` syntax for interpolation
-   - Test with: `echo $GITHUB_TOKEN` to verify it's set
-
-3. **MCP server doesn't start**
-   - Try running the command manually first: `npx -y @modelcontextprotocol/server-filesystem /tmp`
-   - Check for any npm/node errors
-
-4. **"Step not found" errors**
-   - Inline prompts in the workflow use the syntax: `step_name: prompt text`
-   - For multi-line prompts use: `step_name: |` followed by indented text
-   - For separate prompt files: create `step_name/prompt.md` in the workflow directory
-
-## Security Notes
-
-- Never hardcode credentials - use environment variables
-- Use `only` to limit function access when possible
-- Be cautious with stdio tools as they execute local processes
-- Review MCP server documentation for security best practices
-- The filesystem server only allows access to specified directories

data/examples/mcp/analyze_changes/prompt.md

@@ -1,8 +0,0 @@
-For the file <%= resource.target %>:
-1. Read the file contents using read_file
-2. Use the Linter tool to analyze code quality
-3. Check for common issues:
-   - Code style violations
-   - Potential bugs
-   - Performance concerns
-   - Security issues

data/examples/mcp/analyze_issues/prompt.md

@@ -1,4 +0,0 @@
-Based on the issues found:
-1. Identify common patterns or themes
-2. Categorize the bugs by type (UI, performance, functionality, etc.)
-3. Note any critical issues that need immediate attention

data/examples/mcp/analyze_schema/prompt.md

@@ -1,4 +0,0 @@
-Using the database tool:
-1. List all tables in the database
-2. For each major table, describe its structure
-3. Identify relationships between tables

data/examples/mcp/check_data_quality/prompt.md

@@ -1,5 +0,0 @@
-Run queries to check for:
-1. Tables with no data
-2. Potential duplicate records
-3. Missing required fields (NULL values in NOT NULL columns)
-4. Data consistency across related tables

data/examples/mcp/check_documentation/prompt.md

@@ -1,4 +0,0 @@
-Using the GitDocs tool:
-1. Find relevant documentation for the changed code
-2. Determine if documentation updates are needed
-3. Suggest specific documentation changes if required

data/examples/mcp/create_recommendations/prompt.md

@@ -1,5 +0,0 @@
-Create a final report with:
-1. Database health summary
-2. Critical issues that need immediate attention
-3. Performance optimization recommendations
-4. Data quality improvement suggestions

data/examples/mcp/database_workflow.yml

@@ -1,29 +0,0 @@
-# MCP Database Integration Example
-# This workflow demonstrates using a PostgreSQL MCP server for database operations
-
-name: Database Analysis Workflow
-model: gpt-4o-mini
-
-tools:
-  # PostgreSQL MCP tool
-  - Database:
-      command: npx
-      args:
-        - "-y"
-        - "@modelcontextprotocol/server-postgres"
-      env:
-        DATABASE_URL: "{{ENV['DATABASE_URL']}}"
-      only:
-        - query
-        - list_tables
-        - describe_table
-        - get_schema
-
-steps:
-  - analyze_schema
-  - check_data_quality
-  - generate_insights
-  - create_recommendations
-
-create_recommendations:
-  print_response: true

data/examples/mcp/env_demo/workflow.yml

@@ -1,34 +0,0 @@
-# Environment Variable Interpolation Demo
-# This shows how ENV variables are interpolated in MCP tool configurations
-
-name: ENV Interpolation Demo
-model: o4-mini
-
-tools:
-  - Roast::Tools::ReadFile
-  
-  # Filesystem MCP with interpolated path
-  # The user's home directory will be resolved from ENV['HOME']
-  - UserFiles:
-      command: npx
-      args: ["-y", "@modelcontextprotocol/server-filesystem", "{{ENV['HOME'] || '/tmp'}}"]
-      only:
-        - list_directory
-        - get_file_info
-
-steps:
-  - show_env: |
-      First, tell me what user is running this workflow. The current user is: {{ENV['USER'] || 'unknown'}}
-      And their home directory is: {{ENV['HOME'] || 'not set'}}
-      
-  - list_home: |
-      Now use the UserFiles MCP tool's list_directory function to list the user's home directory.
-      Just show the first 5-10 items you find.
-
-
-show_env:
-  print_response: true
-
-list_home:
-  model: gpt-4o-mini
-  print_response: true