roast-ai 0.4.6 → 0.4.8

data/examples/bash_prototyping/api_testing.yml

@@ -1,14 +0,0 @@
-name: API Testing with Bash
-model: gpt-4o-mini
-tools:
-  - Roast::Tools::Bash
-  - Roast::Tools::WriteFile
-
-# Demonstrates using Bash for API testing with curl and jq
-# These commands would be restricted by the Cmd tool
-
-steps:
-  - test_public_api
-  - process_json_response
-  - test_multiple_endpoints
-  - generate_api_report

data/examples/bash_prototyping/check_processes/prompt.md

@@ -1,11 +0,0 @@
-# Check Running Processes
-
-Use the bash tool to analyze running processes:
-
-1. List all processes (ps aux or ps -ef)
-2. Find the top 5 CPU-consuming processes
-3. Find the top 5 memory-consuming processes
-4. Check if any specific development services are running (like databases, web servers)
-5. Count total number of processes
-
-Note: The exact commands may vary between macOS and Linux. Use appropriate commands for the detected OS.

data/examples/bash_prototyping/generate_report/prompt.md

@@ -1,16 +0,0 @@
-# Generate System Analysis Report
-
-Based on all the information gathered in previous steps:
-
-1. Create a comprehensive markdown report summarizing:
-   - System specifications and OS details
-   - Resource usage (CPU, memory, disk)
-   - Active processes and services
-   - Network configuration
-   - Any potential issues or interesting findings
-
-2. Save the report to `system_analysis_report.md` using the write_file tool
-
-3. Include timestamps and organize the information in a clear, readable format
-
-The report should be suitable for sharing with other developers or for documentation purposes.

data/examples/bash_prototyping/process_json_response/prompt.md

@@ -1,24 +0,0 @@
-# Process JSON Responses
-
-Use bash with jq (if available) to process JSON responses:
-
-1. First check if jq is installed:
-   ```bash
-   which jq
-   ```
-
-2. If jq is available, use it to parse JSON:
-   ```bash
-   curl -s https://api.github.com/users/github | jq '.name, .public_repos'
-   ```
-
-3. If jq is not available, use alternative methods like:
-   - grep with regular expressions
-   - sed/awk for parsing
-   - Python one-liners if Python is available
-
-4. Extract specific fields from the API responses
-5. Count items in arrays
-6. Filter data based on conditions
-
-Show different approaches for JSON processing depending on available tools.

data/examples/bash_prototyping/system_analysis.yml

@@ -1,14 +0,0 @@
-name: System Analysis with Bash
-model: gpt-4o-mini
-tools:
-  - Roast::Tools::Bash
-  - Roast::Tools::WriteFile
-
-# This workflow demonstrates using Bash for system analysis tasks
-# that would be restricted by the Cmd tool
-
-steps:
-  - analyze_system
-  - check_processes
-  - analyze_network
-  - generate_report

data/examples/bash_prototyping/test_public_api/prompt.md

@@ -1,22 +0,0 @@
-# Test Public API Endpoints
-
-Use the bash tool to test various public APIs:
-
-1. Test GitHub API:
-   ```bash
-   curl -s https://api.github.com/users/github
-   ```
-
-2. Test a public JSON placeholder API:
-   ```bash
-   curl -s https://jsonplaceholder.typicode.com/posts/1
-   ```
-
-3. Check response headers:
-   ```bash
-   curl -I https://api.github.com
-   ```
-
-4. Test with different HTTP methods if appropriate
-
-Analyze the responses and note the structure of the returned data.

data/examples/case_when/README.md

@@ -1,58 +0,0 @@
-# Case/When/Else Example
-
-This example demonstrates the use of `case/when/else` control flow in Roast workflows.
-
-## Overview
-
-The `case/when/else` construct allows you to execute different steps based on the value of an expression, similar to Ruby's case statement or switch statements in other languages.
-
-## Syntax
-
-```yaml
-- case: <expression>
-  when:
-    <value1>:
-      - <steps>
-    <value2>:
-      - <steps>
-  else:
-    - <steps>
-```
-
-## Features Demonstrated
-
-1. **Basic case/when/else**: Detect file language and execute language-specific analysis
-2. **Bash command evaluation**: Use environment variables to determine deployment strategy
-3. **Complex expressions**: Use Ruby expressions to categorize numeric values
-
-## Expression Types
-
-The `case` expression can be:
-- A simple string value
-- An interpolated workflow output: `{{ workflow.output.variable }}`
-- A Ruby expression: `{{ workflow.output.count > 10 ? 'high' : 'low' }}`
-- A bash command: `$(echo $ENVIRONMENT)`
-- A reference to a previous step's output
-
-## How It Works
-
-1. The `case` expression is evaluated to produce a value
-2. The value is compared against each key in the `when` clause
-3. If a match is found, the steps under that key are executed
-4. If no match is found and an `else` clause exists, those steps are executed
-5. If no match is found and no `else` clause exists, execution continues
-
-## Running the Example
-
-```bash
-roast execute examples/case_when/workflow.yml
-```
-
-This will process all Ruby, JavaScript, Python, and Go files in the current directory, detecting their language and running appropriate analysis steps.
-
-## Use Cases
-
-- **Multi-language projects**: Different linting/testing for different file types
-- **Environment-specific workflows**: Different deployment steps for prod/staging/dev
-- **Conditional processing**: Different handling based on file size, complexity, or other metrics
-- **Error handling**: Different recovery strategies based on error types

data/examples/case_when/detect_language/prompt.md

@@ -1,16 +0,0 @@
-# Detect Programming Language
-
-Based on the file extension and content, determine the primary programming language of this file:
-- If it's a `.rb` file, return "ruby"
-- If it's a `.js` file, return "javascript"
-- If it's a `.py` file, return "python"
-- If it's a `.go` file, return "go"
-- Otherwise, return "unknown"
-
-Return ONLY the language name in lowercase, nothing else.
-
-File: <%= context.resource_uri %>
-Content:
-```
-<%= context.resource %>
-```

data/examples/case_when/workflow.yml

@@ -1,58 +0,0 @@
-name: "Case/When/Else Example"
-
-tools:
-  - Roast::Tools::Cmd
-  - Roast::Tools::ReadFile
-  - Roast::Tools::WriteFile
-
-target: "**/*.{rb,js,py,go}"
-
-steps:
-  - detect_language
-
-  - case: "{{ workflow.output.detect_language }}"
-    when:
-      ruby:
-        - analyze_ruby
-        - generate_ruby_report
-      javascript:
-        - analyze_javascript
-        - generate_js_report
-      python:
-        - analyze_python
-        - generate_python_report
-      go:
-        - analyze_go
-        - generate_go_report
-    else:
-      - analyze_generic
-      - generate_generic_report
-
-  # Another example using bash command for case expression
-  - get_environment: $(echo $ENVIRONMENT || echo "development")
-
-  - case: "{{ workflow.output.get_environment }}"
-    when:
-      production:
-        - production_checks
-        - deploy_production
-      staging:
-        - staging_checks
-        - deploy_staging
-      development:
-        - run_tests
-        - local_deploy
-    else:
-      - unknown_environment
-
-  # Example with numeric case values
-  - count_issues
-
-  - case: "{{ workflow.output.count_issues.to_i > 10 ? 'high' : workflow.output.count_issues.to_i > 5 ? 'medium' : 'low' }}"
-    when:
-      high:
-        - high_priority_alert
-      medium:
-        - medium_priority_notice
-      low:
-        - low_priority_info

data/examples/cmd/README.md

@@ -1,99 +0,0 @@
-# Command Tool Examples
-
-Learn how to execute system commands in your Roast workflows using the Cmd tool. This example demonstrates how to define allowed commands and use them as functions within your workflows.
-
-## Overview
-
-The `Cmd` tool allows you to define a list of approved system commands that can be executed by the AI. Each allowed command is treated as a distinct function, providing several benefits:
-
-- **Security**: Only explicitly allowed commands can be run, preventing unauthorized system access.
-- **Clarity**: Each command has a clear, defined purpose within the workflow.
-- **Intelligent Usage**: Custom descriptions can be provided to help the AI choose the correct command for a given task.
-
-## Configuration
-
-You can configure the `Cmd` tool in your workflow YAML file.
-
-### Basic Configuration
-
-List the commands that the AI is allowed to execute:
-
-```yaml
-tools:
-  - Roast::Tools::Cmd:
-      allowed_commands:
-        - pwd
-        - ls
-        - echo
-```
-
-Each command listed here (`pwd`, `ls`, `echo`) becomes a function the AI can call. For example, the AI can call `pwd()` to get the current directory, or `ls(args: "-la")` to list files.
-
-### Enhanced Configuration with Descriptions
-
-For more complex commands or to provide better guidance to the AI, you can include a description:
-
-```yaml
-tools:
-  - Roast::Tools::Cmd:
-      allowed_commands:
-        - pwd
-        - ls
-        - name: git
-          description: "git CLI - version control system (e.g., git status, git log)"
-        - name: npm
-          description: "npm CLI - Node.js package manager (e.g., npm install, npm run)"
-        - name: docker
-          description: "Docker CLI - container platform (e.g., docker ps, docker run)"
-```
-These descriptions help the AI understand the purpose of each command and its common subcommands or arguments.
-
-## How It Works
-
-When the `Cmd` tool is configured, each entry in `allowed_commands` is registered as a function available to the AI.
-
-- `pwd` becomes `pwd()`
-- `ls` becomes `ls(args: <string>)`
-- `git` (with a description) becomes `git(args: <string>)`
-
-The AI can then choose to call these functions with appropriate arguments (passed via the `args` parameter) to accomplish its tasks.
-
-## Example Workflows
-
-This directory contains several example workflows demonstrating different uses of the `Cmd` tool:
-
-- **`basic_workflow.yml`**: Introduces simple command execution.
-- **`explorer_workflow.yml`**: Uses commands to navigate and understand a project structure.
-- **`dev_workflow.yml`**: Showcases how descriptions guide the AI in selecting tools for development-related tasks.
-
-## Running the Examples
-
-To run an example workflow:
-```bash
-bin/roast execute examples/cmd/NAME_OF_WORKFLOW.yml
-```
-For instance:
-```bash
-bin/roast execute examples/cmd/basic_workflow.yml
-```
-
-## Security
-
-Explicitly defining `allowed_commands` is crucial for security:
-- You maintain full control over which system commands the AI can execute.
-- It creates self-documenting configurations, making workflows safer and more predictable.
-
-## Best Practices
-
-- **Start Simple**: Begin with basic commands like `pwd` and `ls`.
-- **Use Descriptions for Clarity**: Provide descriptions for commands that are not universally understood or have complex arguments/subcommands. This helps both the AI and human readers.
-- **Scope Appropriately**: Only allow commands that are necessary for the workflow's intended purpose.
-
-## Why Use Custom Descriptions?
-
-Custom descriptions are particularly useful when:
-- Dealing with domain-specific or less common commands.
-- Disambiguating between commands with similar names or overlapping functionality.
-- Guiding the AI to make more informed decisions about tool selection.
-
-Good descriptions enhance the AI's ability to use commands effectively and make your workflows more robust.

data/examples/cmd/analyze_project/prompt.md

@@ -1,57 +0,0 @@
-# Project Analysis
-
-You need to analyze the current project to identify its type, available tools, and development setup. Gather comprehensive information to understand the project's nature and configuration.
-
-Investigate the project to determine:
-
-1. Your current working location
-2. The project structure and contents
-3. Whether this is a Node.js project (look for package.json)
-4. Whether Docker is configured (look for Dockerfile or docker-compose.yml)
-5. Whether there's a Makefile for build automation
-6. The version control state
-
-Based on your findings, determine:
-- Project type (Node.js application, containerized service, make-based project, etc.)
-- Available development tools and configurations
-- How dependencies are managed
-- Version control status
-- Recommended next steps for development
-
-RESPONSE FORMAT
-Provide your analysis in JSON format:
-
-<json>
-{
-  "project_analysis": {
-    "working_directory": "/path/to/project",
-    "project_type": "Identified based on available files",
-    "detected_tools": {
-      "node_project": {
-        "has_package_json": false,
-        "has_lock_file": false,
-        "package_manager": "none"
-      },
-      "containerization": {
-        "has_dockerfile": false,
-        "has_compose": false,
-        "docker_ready": false
-      },
-      "build_system": {
-        "has_makefile": false,
-        "make_targets": []
-      },
-      "version_control": {
-        "has_git": true,
-        "working_tree_clean": false,
-        "uncommitted_changes": 3
-      }
-    },
-    "recommendations": [
-      "Relevant recommendations based on what was found"
-    ],
-    "confidence": "high"
-  },
-  "analysis_complete": true
-}
-</json>

data/examples/cmd/basic_demo/prompt.md

@@ -1,48 +0,0 @@
-# Basic Command Demonstration
-
-You are demonstrating basic command functions. Execute several simple commands to show how the command tool system works.
-
-**SPECIFIC TASKS:**
-1. Show the current working directory: use `pwd`
-2. List all files with details: use `ls -la`
-3. Display celebratory message: use `echo "🎉 Command functions are working!"`
-4. List examples directory: use `ls examples/`
-
-**EFFICIENCY RULES:**
-- Execute each command ONLY ONCE
-- DO NOT repeat any command
-- Follow the exact order above
-
-Each command execution demonstrates how commands are called as functions in the workflow, with security enforced through the workflow's configuration.
-
-RESPONSE FORMAT
-Provide a summary of your command executions in JSON format:
-
-<json>
-{
-  "demonstration_complete": true,
-  "commands_executed": [
-    {
-      "command": "pwd",
-      "purpose": "Show current working directory",
-      "output_summary": "Current directory path"
-    },
-    {
-      "command": "ls -la",
-      "purpose": "List all files with details",
-      "output_summary": "Directory listing with permissions and sizes"
-    },
-    {
-      "command": "echo \"🎉 Command functions are working!\"",
-      "purpose": "Display test message",
-      "output_summary": "Success message displayed"
-    },
-    {
-      "command": "ls examples/",
-      "purpose": "List examples directory",
-      "output_summary": "Contents of examples directory"
-    }
-  ],
-  "conclusion": "Successfully demonstrated basic command functions with security constraints"
-}
-</json>

data/examples/cmd/basic_workflow.yml

@@ -1,17 +0,0 @@
-name: Basic Command Functions
-model: default
-
-# Learn the basics of using command functions in Roast
-
-tools:
-  - Roast::Tools::Cmd:
-      allowed_commands:
-        - pwd
-        - ls
-        - echo
-        - mkdir
-        - cat
-
-steps:
-  - basic_demo
-  - create_and_verify

data/examples/cmd/check_repository/prompt.md

@@ -1,57 +0,0 @@
-# Repository Status Check
-
-You need to analyze the Git repository status and provide a comprehensive overview of the repository state, history, and configuration.
-
-**SPECIFIC COMMANDS TO USE:**
-1. Check repository status: `git status`
-2. Show current branch: `git branch --show-current`
-3. List recent commits: `git log --oneline -10`
-4. Show remote repositories: `git remote -v`
-
-**EFFICIENCY RULES:**
-- Run each command ONLY ONCE - do not repeat any git command
-- DO NOT try different variations of the same command (e.g., different log formats)
-- Gather all needed information with these 4 commands only
-
-From these commands, analyze:
-- Current branch and its state
-- Working directory status (clean/dirty)
-- Recent commit activity
-- Remote repository configuration
-- Overall repository health
-
-RESPONSE FORMAT
-Provide your analysis in JSON format:
-
-<json>
-{
-  "repository_status": {
-    "current_branch": "main",
-    "working_directory": {
-      "is_clean": false,
-      "modified_files": 3,
-      "untracked_files": 2,
-      "staged_changes": 1
-    },
-    "recent_activity": {
-      "total_recent_commits": 10,
-      "latest_commit": {
-        "hash": "abc1234",
-        "message": "Latest commit message"
-      },
-      "activity_summary": "Regular commits indicate active development"
-    },
-    "remotes": {
-      "origin": {
-        "fetch_url": "https://github.com/user/repo.git",
-        "push_url": "https://github.com/user/repo.git"
-      }
-    },
-    "repository_health": {
-      "status": "healthy",
-      "notes": "Repository has uncommitted changes but is otherwise in good state"
-    }
-  },
-  "analysis_complete": true
-}
-</json>

data/examples/cmd/create_and_verify/prompt.md

@@ -1,56 +0,0 @@
-# Creating and Verifying Files
-
-You need to demonstrate file creation and verification capabilities. Create a test directory and file, then verify the operations were successful.
-
-**EXECUTE THESE COMMANDS IN ORDER:**
-1. Create directory: `mkdir -p test_cmd_demo`
-2. Create file: `echo "This file was created by command functions!" > test_cmd_demo/demo.txt`
-3. Verify directory: `ls -la test_cmd_demo/`
-4. Verify content: `cat test_cmd_demo/demo.txt`
-5. Show completion: `echo "Demo complete! You can remove test_cmd_demo when ready."`
-
-**EFFICIENCY RULE:** Execute each command exactly once in the order shown above.
-
-This exercise demonstrates how command functions can be combined for practical file operations while maintaining security through the workflow's command restrictions.
-
-RESPONSE FORMAT
-Report the results in JSON format:
-
-<json>
-{
-  "task_completed": true,
-  "operations": [
-    {
-      "step": "create_directory",
-      "command": "mkdir -p test_cmd_demo",
-      "success": true,
-      "result": "Directory created successfully"
-    },
-    {
-      "step": "create_file",
-      "command": "echo \"This file was created by command functions!\" > test_cmd_demo/demo.txt",
-      "success": true,
-      "result": "File created with content"
-    },
-    {
-      "step": "verify_creation",
-      "command": "ls -la test_cmd_demo/",
-      "success": true,
-      "result": "Directory listing shows demo.txt file"
-    },
-    {
-      "step": "verify_content",
-      "command": "cat test_cmd_demo/demo.txt",
-      "success": true,
-      "result": "File contents match expected text"
-    },
-    {
-      "step": "completion_message",
-      "command": "echo \"Demo complete! You can remove test_cmd_demo when ready.\"",
-      "success": true,
-      "result": "Completion message displayed"
-    }
-  ],
-  "summary": "Successfully demonstrated file creation and verification using command functions"
-}
-</json>

data/examples/cmd/dev_workflow.yml

@@ -1,26 +0,0 @@
-name: Development Tools Workflow
-model: default
-
-# Demonstrates how custom descriptions guide intelligent tool selection
-
-tools:
-  - Roast::Tools::Cmd:
-      allowed_commands:
-        - pwd
-        - ls
-        - name: git
-          description: "git CLI - version control system with subcommands like status, commit, branch"
-        - name: npm
-          description: "npm CLI - Node.js package manager with subcommands like install, run, test"
-        - name: docker
-          description: "Docker CLI - container platform with subcommands like ps, run, build"
-        - name: curl
-          description: "curl command - make HTTP requests with options like -X, -H, -d"
-        - name: jq
-          description: "jq command - process JSON data with filters like '.key', '.[].name'"
-        - name: make
-          description: "make command - run build targets defined in Makefile"
-
-steps:
-  - analyze_project
-  - smart_tool_selection