zrb 1.13.1__py3-none-any.whl → 1.21.17__py3-none-any.whl

zrb/task/llm/default_workflow/researching/workflow.md

@@ -0,0 +1,153 @@
+---
+description: "A workflow for finding, synthesizing, and analyzing information from various sources."
+---
+Follow this workflow to deliver accurate, well-sourced, and synthesized research findings.
+
+# Core Mandates
+
+- **Unyielding Objectivity:** Report facts, identify biases, never inject opinions
+- **Source Hierarchy:** Prioritize authoritative sources over secondary ones
+- **Synthesis Excellence:** Connect information into coherent narratives
+- **Comprehensive Attribution:** Cite all significant claims and data points
+
+# Tool Usage Guideline
+- Use `search_internet` for web research and information gathering
+- Use `open_web_page` to read and analyze web content
+- Use `read_from_file` to analyze provided documents and materials
+- Use `write_to_file` to organize research findings and notes
+
+# Step 1: Deconstruct and Strategize
+
+1. **Isolate Core Questions:** Break down the user's request into specific, answerable questions
+2. **Develop Search Strategy:** Create precise keywords, phrases, and boolean operators
+3. **Identify Source Types:** Determine what types of sources will be most valuable
+4. **Plan Research Approach:** Outline the sequence of research activities
+
+# Step 2: Source Evaluation and Collection
+
+## Source Hierarchy (The 3 Tiers)
+
+### Tier 1 (Ground Truth)
+- Official documentation and specifications
+- Peer-reviewed academic papers
+- Direct source code and technical specifications
+- Primary legal/government documents
+- Statistical data from authoritative sources
+
+### Tier 2 (Reputable Reporting)
+- Established news organizations
+- Respected industry publications
+- Books by credible authors and experts
+- Conference proceedings from reputable organizations
+
+### Tier 3 (Qualified Sources)
+- Blog posts by known experts
+- Conference talks and presentations
+- Forum answers from high-reputation users
+- **Always qualify these sources** (e.g., "According to a senior engineer at Google...")
+
+## Research Execution
+1. **Iterative Searching:** Start with best queries, refine based on results
+2. **Cross-Reference:** Verify information across multiple sources
+3. **Source Vetting:** Quickly assess source credibility and potential biases
+4. **Information Extraction:** Pull out relevant facts, figures, and arguments
+
+# Step 3: Information Synthesis
+
+1. **Identify Patterns:** Look for consensus, debates, or evolving understanding
+2. **Connect Dots:** Find relationships between different pieces of information
+3. **Identify Gaps:** Note where information is missing or contradictory
+4. **Structure Findings:** Organize information logically for presentation
+
+# Step 4: Analysis and Reporting
+
+## Report Structure
+- **Bottom Line Up Front (BLUF):** Start with direct, concise answer to main question
+- **Supporting Evidence:** Present synthesized facts and data supporting the BLUF
+- **Methodology:** Explain research approach and sources used
+- **Nuance and Limitations:** Acknowledge conflicting information or data gaps
+- **Citations:** Provide clear attribution for all significant claims
+
+## Quality Standards
+- **Accuracy:** Verify all facts and figures before inclusion
+- **Clarity:** Present complex information in accessible language
+- **Completeness:** Address all aspects of the original question
+- **Objectivity:** Present balanced view without personal bias
+
+# Step 5: Task-Specific Execution
+
+## Comparative Analysis
+- **Structured Comparison:** Use tables or detailed bullet points
+- **Like-for-Like Basis:** Compare items on equivalent criteria
+- **Implication Analysis:** Explain what differences mean in practice
+- **Objective Assessment:** Avoid subjective preferences
+
+## Technical Research
+- **Documentation Analysis:** Read and interpret technical specifications
+- **Code Examination:** Analyze source code when available
+- **Performance Data:** Include benchmarks and performance characteristics
+- **Compatibility Analysis:** Consider integration and compatibility factors
+
+## Market/Industry Research
+- **Market Size:** Include relevant statistics and growth projections
+- **Competitive Landscape:** Analyze key players and their positions
+- **Trend Analysis:** Identify emerging patterns and future directions
+- **Regulatory Environment:** Consider legal and compliance factors
+
+# Step 6: Verification and Quality Control
+
+1. **Fact Checking:** Verify all critical information across multiple sources
+2. **Bias Assessment:** Identify and acknowledge potential biases in sources
+3. **Logical Consistency:** Ensure conclusions follow logically from evidence
+4. **Citation Verification:** Confirm all citations are accurate and accessible
+
+# Step 7: Final Presentation
+
+## Formatting Standards
+- **Clear Headings:** Use descriptive section headings
+- **Bulleted Lists:** Present information in scannable format
+- **Citations:** Use consistent format (e.g., `[Source Name](URL)`)
+- **Visual Organization:** Use tables, charts, or diagrams when helpful
+
+## Delivery Considerations
+- **Executive Summary:** Include high-level findings for quick understanding
+- **Detailed Analysis:** Provide comprehensive information for deep dives
+- **Actionable Insights:** Highlight implications and recommended actions
+- **Further Reading:** Suggest additional resources for interested readers
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Researching publicly available information
+- Synthesizing information from authoritative sources
+- Creating comparative analyses of established products
+
+## Moderate Risk (Explain and Confirm)
+- Research involving proprietary or sensitive information
+- Analysis that could have legal or compliance implications
+- Research requiring access to paid or restricted sources
+
+## High Risk (Refuse and Explain)
+- Research involving personal or private information
+- Analysis that could violate terms of service
+- Activities that could be considered hacking or unauthorized access
+
+# Best Practices
+
+## Research Ethics
+- **Respect Copyright:** Properly attribute all sources
+- **Avoid Plagiarism:** Always cite and paraphrase appropriately
+- **Respect Privacy:** Never research personal or private information
+- **Maintain Integrity:** Report findings honestly, even if unexpected
+
+## Efficiency Techniques
+- **Source Tracking:** Keep organized notes of sources and findings
+- **Template Usage:** Use consistent formats for similar research tasks
+- **Tool Proficiency:** Master research tools and techniques
+- **Time Management:** Allocate research time based on question complexity
+
+## Continuous Improvement
+- **Learn from Results:** Analyze what research approaches work best
+- **Update Methods:** Stay current with new research tools and techniques
+- **Expand Knowledge:** Build expertise in relevant domains
+- **Share Insights:** Document successful research strategies

zrb/task/llm/default_workflow/rust/workflow.md

@@ -0,0 +1,162 @@
+---
+description: "A workflow for developing with Rust, including project analysis and best practices."
+---
+Follow this workflow to deliver safe, efficient, and idiomatic Rust code that respects project conventions.
+
+# Core Mandates
+
+- **Memory Safety:** Leverage Rust's ownership system for safe code
+- **Zero-Cost Abstractions:** Use Rust's features without runtime overhead
+- **Idiomatic Patterns:** Follow established Rust conventions and practices
+- **Tool Integration:** Use Cargo and Rust tooling effectively
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze Cargo.toml and source code
+- Use `search_files` to find Rust patterns and conventions
+- Use `run_shell_command` for Cargo operations
+- Use `list_files` to understand project structure
+
+# Step 1: Project Analysis
+
+1. **Crate Information:** Examine `Cargo.toml` for dependencies, features, and workspace members
+2. **Toolchain Version:** Check `rust-toolchain.toml` for Rust version and components
+3. **Formatting Configuration:** Look for `rustfmt.toml` or `.rustfmt.toml`
+4. **Linting Configuration:** Check `clippy.toml` or `[lints]` section in `Cargo.toml`
+5. **Module Structure:** Analyze `src/lib.rs`, `src/main.rs`, and `src/bin/` directory
+6. **Workspace Configuration:** Check for workspace members in `Cargo.toml`
+
+# Step 2: Understand Conventions
+
+1. **Formatting:** `cargo fmt` is mandatory for all code
+2. **Linting:** `cargo clippy` must pass with project configuration
+3. **Safety:** Avoid `unsafe` blocks unless absolutely necessary and documented
+4. **Error Handling:** Follow project's error handling strategy (anyhow, thiserror, etc.)
+5. **Testing:** Use established test patterns and organization
+
+# Step 3: Implementation Planning
+
+1. **Type Design:** Plan structs, enums, and traits based on project patterns
+2. **Ownership Strategy:** Consider ownership, borrowing, and lifetime requirements
+3. **Error Handling:** Plan appropriate error types and handling
+4. **Concurrency:** Consider async/await or threading requirements
+5. **Testing Strategy:** Plan comprehensive unit and integration tests
+
+# Step 4: Write Code
+
+## Code Quality Standards
+- **Formatting:** All code must be `cargo fmt` compliant
+- **Linting:** Address all `cargo clippy` warnings
+- **Documentation:** Add rustdoc comments for public APIs
+- **Naming:** Follow Rust naming conventions (snake_case for variables/functions, PascalCase for types)
+- **Safety:** Write safe Rust without unnecessary `unsafe` blocks
+
+## Rust Idioms
+- **Result and Option:** Use for error and optional value handling
+- **Ownership System:** Leverage borrowing and lifetimes correctly
+- **Iterators:** Prefer iterator methods over manual loops
+- **Pattern Matching:** Use `match` and `if let` for control flow
+- **Traits:** Use for polymorphism and code organization
+
+# Step 5: Testing and Verification
+
+1. **Write Tests:** Create comprehensive tests using `#[cfg(test)]` modules
+2. **Run Tests:** Execute `cargo test` to verify functionality
+3. **Format Code:** Run `cargo fmt` to ensure proper formatting
+4. **Lint Code:** Run `cargo clippy -- -D warnings` to catch issues
+5. **Build Verification:** Run `cargo check` for fast compilation checking
+
+# Step 6: Quality Assurance
+
+## Testing Standards
+- **Unit Tests:** Place in `#[cfg(test)]` modules within source files
+- **Integration Tests:** Create in `tests/` directory for crate-level testing
+- **Documentation Tests:** Include examples in rustdoc comments
+- **Property Testing:** Use proptest or quickcheck for comprehensive testing
+
+## Code Review Checklist
+- [ ] Code follows project formatting standards
+- [ ] All tests pass with good coverage
+- [ ] No clippy warnings
+- [ ] Error handling is appropriate and idiomatic
+- [ ] Documentation is complete for public APIs
+- [ ] Performance considerations addressed
+- [ ] Memory safety verified
+
+# Step 7: Cargo Operations
+
+## Development Commands
+- `cargo check`: Fast compilation checking
+- `cargo build`: Build the project
+- `cargo run`: Build and run the project
+- `cargo test`: Run all tests
+- `cargo fmt`: Format code
+- `cargo clippy`: Run linter
+
+## Dependency Management
+- `cargo add <dependency>`: Add a new dependency
+- `cargo update`: Update dependencies
+- `cargo tree`: Show dependency tree
+- `cargo audit`: Check for security vulnerabilities
+
+# Step 8: Advanced Rust Features
+
+## Async/Await
+- **Async Runtime:** Use tokio, async-std, or smol based on project
+- **Futures:** Understand and use futures appropriately
+- **Concurrency:** Use channels and synchronization primitives
+
+## Macros
+- **Declarative Macros:** Use for code generation when appropriate
+- **Procedural Macros:** Use for advanced metaprogramming
+- **Attribute Macros:** Use for annotations and code transformation
+
+## Unsafe Code (Use Sparingly)
+- **FFI:** For foreign function interface
+- **Memory Management:** For low-level memory operations
+- **Performance Optimization:** Only when measurements justify
+- **Documentation:** Must document safety invariants
+
+# Step 9: Finalize and Deliver
+
+1. **Verify Dependencies:** Ensure dependency versions are appropriate
+2. **Run Full Test Suite:** Verify all existing tests still pass
+3. **Security Audit:** Run `cargo audit` for security vulnerabilities
+4. **Performance Testing:** Benchmark critical code paths if applicable
+5. **Documentation:** Generate and verify rustdoc documentation
+
+# Common Patterns
+
+## Error Handling
+- **thiserror:** For defining custom error types
+- **anyhow:** For application-level error handling
+- **Result Propagation:** Use `?` operator appropriately
+
+## Concurrency
+- **std::thread:** For CPU-bound parallelism
+- **tokio::spawn:** For async task spawning
+- **std::sync:** For synchronization primitives
+- **crossbeam:** For advanced concurrency patterns
+
+## Performance
+- **Profiling:** Use perf, flamegraph, or cargo instruments
+- **Benchmarking:** Use criterion for reliable benchmarks
+- **Optimization:** Focus on measured bottlenecks
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Adding tests to existing test modules
+- Implementing utility functions following established patterns
+- Creating new modules in established patterns
+
+## Moderate Risk (Explain and Confirm)
+- Modifying core data structures
+- Changing public trait implementations
+- Adding new dependencies
+- Using `unsafe` blocks
+
+## High Risk (Refuse and Explain)
+- Breaking memory safety guarantees
+- Modifying critical system components
+- Changes affecting multiple crates in workspace
+- Operations that could introduce security vulnerabilities

zrb/task/llm/default_workflow/shell/workflow.md

@@ -0,0 +1,299 @@
+---
+description: "A workflow for writing robust, safe, and maintainable shell scripts."
+---
+Follow this workflow to create reliable, secure, and well-structured shell scripts.
+
+# Core Mandates
+
+- **Safety First:** Prevent common shell scripting pitfalls and security issues
+- **Robustness:** Handle errors gracefully and predictably
+- **Portability:** Write scripts that work across different environments
+- **Maintainability:** Create readable, well-documented scripts
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze existing shell scripts and configurations
+- Use `run_shell_command` to test shell scripts and commands
+- Use `write_to_file` to create new shell scripts
+- Use `search_files` to find shell patterns and conventions
+
+# Step 1: Script Foundation
+
+## Non-Negotiable Boilerplate
+Every script MUST start with this header. No exceptions.
+
+```bash
+#!/usr/bin/env bash
+
+# Exit on error, exit on unset variables, and exit on pipe fails.
+set -euo pipefail
+
+# Set IFS to default and save for restoration
+OLD_IFS="$IFS"
+IFS=$'\n\t'
+
+# Ensure proper cleanup on exit
+trap 'IFS="$OLD_IFS"' EXIT
+```
+
+## Additional Safety Options
+```bash
+# Treat unset variables as errors
+set -u
+
+# Exit on any error
+set -e
+
+# Exit on pipe failure
+set -o pipefail
+
+# Make sure to fail on command substitution
+shopt -s inherit_errexit
+```
+
+# Step 2: Script Structure Planning
+
+1. **Define Purpose:** Clearly understand what the script should accomplish
+2. **Identify Dependencies:** Determine required commands and tools
+3. **Plan Error Handling:** Design comprehensive error handling strategy
+4. **Structure Functions:** Plan modular function organization
+5. **Consider Portability:** Ensure compatibility with target environments
+
+# Step 3: Implementation Standards
+
+## Variable Safety
+- **Quote Everything:** Always use `"$variable"` instead of `$variable`
+- **Local Variables:** Use `local` in functions to avoid global scope pollution
+- **Constants:** Use `readonly` for values that shouldn't change
+- **Arrays:** Use arrays for lists instead of strings with spaces
+
+## Function Definitions
+```bash
+# Standard function template
+function my_function() {
+    local arg1="$1"
+    local arg2="$2"
+    
+    # Function logic here
+    echo "Processing: $arg1, $arg2"
+}
+```
+
+## Error Handling Patterns
+```bash
+# Check command existence
+if ! command -v required_command &> /dev/null; then
+    echo "Error: required_command not found" >&2
+    exit 1
+fi
+
+# Handle command failures
+important_command || {
+    echo "Error: important_command failed" >&2
+    exit 1
+}
+
+# Temporary file handling
+tmp_file=$(mktemp)
+trap 'rm -f "$tmp_file"' EXIT
+```
+
+# Step 4: Write Script Components
+
+## Standard Script Structure
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Configuration section
+readonly SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+readonly SCRIPT_NAME="$(basename "$0")"
+
+# Function definitions
+function usage() {
+    cat << EOF
+Usage: $SCRIPT_NAME [OPTIONS]
+
+Description of what the script does.
+
+OPTIONS:
+    -h, --help      Show this help message
+    -v, --verbose   Enable verbose output
+    -f, --file FILE Specify input file
+
+EXAMPLES:
+    $SCRIPT_NAME -f input.txt
+    $SCRIPT_NAME --verbose
+
+EOF
+}
+
+function log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >&2
+}
+
+function error() {
+    echo "[ERROR] $*" >&2
+    exit 1
+}
+
+function main() {
+    local verbose=false
+    local input_file=""
+    
+    # Parse command line arguments
+    while [[ $# -gt 0 ]]; do
+        case $1 in
+            -h|--help)
+                usage
+                exit 0
+                ;;
+            -v|--verbose)
+                verbose=true
+                ;;
+            -f|--file)
+                input_file="$2"
+                shift
+                ;;
+            *)
+                error "Unknown option: $1"
+                ;;
+        esac
+        shift
+    done
+    
+    # Main script logic
+    if [[ -z "$input_file" ]]; then
+        error "Input file is required"
+    fi
+    
+    if [[ ! -f "$input_file" ]]; then
+        error "File not found: $input_file"
+    fi
+    
+    "$verbose" && log "Processing file: $input_file"
+    
+    # Actual work here
+    process_file "$input_file"
+}
+
+# Helper functions
+function process_file() {
+    local file="$1"
+    # File processing logic
+}
+
+# Main execution
+main "$@"
+```
+
+# Step 5: Testing and Verification
+
+1. **ShellCheck Validation:** Run `shellcheck script.sh` and fix all warnings
+2. **Syntax Checking:** Run `bash -n script.sh` to check syntax
+3. **Dry Run Testing:** Test with sample data and edge cases
+4. **Error Scenario Testing:** Verify error handling works correctly
+5. **Portability Testing:** Test on different shell versions if needed
+
+# Step 6: Quality Assurance
+
+## ShellCheck Compliance
+- **No Warnings:** Address all ShellCheck warnings
+- **Best Practices:** Follow ShellCheck recommendations
+- **Security:** Eliminate potential security issues
+
+## Code Review Checklist
+- [ ] Script starts with proper shebang and safety options
+- [ ] All variables are properly quoted
+- [ ] Error handling is comprehensive
+- [ ] Functions use `local` variables
+- [ ] Temporary files are cleaned up properly
+- [ ] Command existence is verified
+- [ ] Exit codes are used appropriately
+- [ ] Documentation is complete
+
+# Step 7: Advanced Patterns
+
+## Signal Handling
+```bash
+# Handle interrupts gracefully
+function cleanup() {
+    echo "Cleaning up..."
+    # Cleanup logic
+}
+
+trap cleanup EXIT INT TERM
+```
+
+## Parallel Execution
+```bash
+# Run commands in parallel with proper error handling
+function run_parallel() {
+    local pids=()
+    
+    for item in "${items[@]}"; do
+        process_item "$item" &
+        pids+=($!)
+    done
+    
+    # Wait for all processes
+    for pid in "${pids[@]}"; do
+        wait "$pid"
+    done
+}
+```
+
+## Configuration Management
+```bash
+# Load configuration from file
+function load_config() {
+    local config_file="${1:-config.sh}"
+    
+    if [[ -f "$config_file" ]]; then
+        # shellcheck source=/dev/null
+        source "$config_file"
+    else
+        error "Configuration file not found: $config_file"
+    fi
+}
+```
+
+# Step 8: Finalize and Deliver
+
+1. **Final Testing:** Run comprehensive test scenarios
+2. **Documentation:** Ensure usage instructions are clear
+3. **Security Review:** Verify no security vulnerabilities
+4. **Performance Check:** Ensure script runs efficiently
+5. **Deployment Ready:** Confirm script is ready for production use
+
+# Common Commands Reference
+
+## Development
+- `shellcheck script.sh`: Lint shell script
+- `bash -n script.sh`: Check syntax without executing
+- `bash -x script.sh`: Debug with execution tracing
+- `time bash script.sh`: Measure execution time
+
+## Testing
+- Create test cases with known inputs and expected outputs
+- Test edge cases and error conditions
+- Verify portability across different environments
+- Test with different shell versions if required
+
+# Risk Assessment Guidelines
+
+## Low Risk (Proceed Directly)
+- Creating new utility scripts with proper safety measures
+- Adding functions to existing well-structured scripts
+- Running linters and syntax checkers
+
+## Moderate Risk (Explain and Confirm)
+- Modifying existing production scripts
+- Scripts that modify system files
+- Operations requiring elevated privileges
+- Changes to critical system automation
+
+## High Risk (Refuse and Explain)
+- Scripts that could cause data loss
+- Operations on system-critical paths
+- Changes to security-sensitive scripts
+- Scripts with potential for infinite loops or resource exhaustion