zrb 1.21.29__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

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

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

zrb/task/llm/error.py

@@ -1,95 +0,0 @@
-import json
-from typing import TYPE_CHECKING, Any, Optional
-
-if TYPE_CHECKING:
-    from openai import APIError
-
-
-# Define a structured error model for tool execution failures
-class ToolExecutionError:
-    def __init__(
-        self,
-        tool_name: str,
-        error_type: str,
-        message: str,
-        details: Optional[str] = None,
-    ):
-        self.tool_name = tool_name
-        self.error_type = error_type
-        self.message = message
-        self.details = details
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "tool_name": self.tool_name,
-            "error_type": self.error_type,
-            "message": self.message,
-            "details": self.details,
-        }
-
-    def model_dump_json(self, indent: int = 2) -> str:
-        return json.dumps(self.to_dict(), indent=indent)
-
-
-def extract_api_error_details(error: "APIError") -> str:
-    """Extract detailed error information from an APIError."""
-    details = f"{error.message}"
-    # Try to parse the error body as JSON
-    if error.body:
-        try:
-            if isinstance(error.body, str):
-                body_json = json.loads(error.body)
-            elif isinstance(error.body, bytes):
-                body_json = json.loads(error.body.decode("utf-8"))
-            else:
-                body_json = error.body
-            # Extract error details from the JSON structure
-            if isinstance(body_json, dict):
-                if "error" in body_json:
-                    error_obj = body_json["error"]
-                    if isinstance(error_obj, dict):
-                        if "message" in error_obj:
-                            details += f"\nProvider message: {error_obj['message']}"
-                        if "code" in error_obj:
-                            details += f"\nError code: {error_obj['code']}"
-                        if "status" in error_obj:
-                            details += f"\nStatus: {error_obj['status']}"
-                # Check for metadata that might contain provider-specific information
-                if "metadata" in body_json and isinstance(body_json["metadata"], dict):
-                    metadata = body_json["metadata"]
-                    if "provider_name" in metadata:
-                        details += f"\nProvider: {metadata['provider_name']}"
-                    if "raw" in metadata:
-                        try:
-                            raw_json = json.loads(metadata["raw"])
-                            if "error" in raw_json and isinstance(
-                                raw_json["error"], dict
-                            ):
-                                raw_error = raw_json["error"]
-                                if "message" in raw_error:
-                                    details += (
-                                        f"\nRaw error message: {raw_error['message']}"
-                                    )
-                        except (KeyError, TypeError, ValueError):
-                            # If we can't parse the raw JSON, just include it as is
-                            details += f"\nRaw error data: {metadata['raw']}"
-        except json.JSONDecodeError:
-            # If we can't parse the JSON, include the raw body
-            details += f"\nRaw error body: {error.body}"
-        except Exception as e:
-            # Catch any other exceptions during parsing
-            details += f"\nError parsing error body: {str(e)}"
-    # Include request information if available
-    if hasattr(error, "request") and error.request:
-        if hasattr(error.request, "method") and hasattr(error.request, "url"):
-            details += f"\nRequest: {error.request.method} {error.request.url}"
-        # Include a truncated version of the request content if available
-        if hasattr(error.request, "content") and error.request.content:
-            content = error.request.content
-            if isinstance(content, bytes):
-                try:
-                    content = content.decode("utf-8")
-                except UnicodeDecodeError:
-                    content = str(content)
-            details += f"\nRequest content: {content}"
-    return details

zrb/task/llm/file_replacement.py

@@ -1,206 +0,0 @@
-import difflib
-import os
-import shlex
-import subprocess
-import tempfile
-from typing import Any
-
-from zrb.config.config import CFG
-from zrb.task.llm.file_tool_model import FileReplacement
-from zrb.util.file import read_file
-
-
-def is_single_path_replacement(param: Any):
-    if isinstance(param, dict):
-        return _dict_has_exact_keys(
-            param, {"path", "old_text", "new_text"}
-        ) or _dict_has_exact_keys(param, {"path", "old_text", "new_text", "count"})
-    if isinstance(param, list):
-        current_path = None
-        for single_replacement in param:
-            if not is_single_path_replacement(single_replacement):
-                return False
-            if current_path is not None and current_path != single_replacement["path"]:
-                return False
-            current_path = single_replacement["path"]
-        return True
-    return False
-
-
-def _dict_has_exact_keys(dictionary: dict, required_keys: set) -> bool:
-    """
-    Check if a dictionary contains exactly the specified keys.
-    More efficient for large dictionaries.
-    """
-    if len(dictionary) != len(required_keys):
-        return False
-    return all(key in dictionary for key in required_keys)
-
-
-def edit_replacement(
-    replacement: list[FileReplacement] | FileReplacement,
-    diff_edit_command_tpl: str | None = None,
-) -> tuple[list[FileReplacement] | FileReplacement, bool]:
-    # Normalize input to list
-    replacement_list = [replacement] if isinstance(replacement, dict) else replacement
-    if not replacement_list:
-        return replacement, False
-    path = replacement_list[0]["path"]
-    original_content = read_file(path)
-    # Calculate initial proposed content based on AI's suggestion
-    proposed_content = _apply_initial_replacements(original_content, replacement_list)
-    # Open external editor for user modification
-    edited_content = _open_diff_editor(
-        path, original_content, proposed_content, diff_edit_command_tpl
-    )
-    # If content hasn't changed from proposal, return original replacement
-    if edited_content == proposed_content:
-        return replacement, False
-    # Calculate optimized replacements based on user's final edit
-    optimized_replacements = _generate_optimized_replacements(
-        path, original_content, edited_content
-    )
-    return optimized_replacements, True
-
-
-def _apply_initial_replacements(
-    content: str, replacement_list: list[FileReplacement]
-) -> str:
-    new_content = content
-    for single_replacement in replacement_list:
-        old_text = single_replacement["old_text"]
-        new_text = single_replacement["new_text"]
-        count = single_replacement.get("count", -1)
-        new_content = new_content.replace(old_text, new_text, count)
-    return new_content
-
-
-def _open_diff_editor(
-    original_path: str,
-    original_content: str,
-    proposed_content: str,
-    diff_edit_command_tpl: str | None,
-) -> str:
-    if diff_edit_command_tpl is None:
-        diff_edit_command_tpl = CFG.DEFAULT_DIFF_EDIT_COMMAND_TPL
-    _, extension = os.path.splitext(original_path)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=extension) as old_file:
-        old_file_name = old_file.name
-        old_file.write(original_content.encode())
-        old_file.flush()
-        with tempfile.NamedTemporaryFile(delete=False, suffix=extension) as new_file:
-            new_file_name = new_file.name
-            new_file.write(proposed_content.encode())
-            new_file.flush()
-            diff_edit_command = diff_edit_command_tpl.format(
-                old=old_file_name, new=new_file_name
-            )
-            subprocess.call(shlex.split(diff_edit_command))
-            edited_content = read_file(new_file_name)
-    if os.path.exists(old_file_name):
-        os.remove(old_file_name)
-    if os.path.exists(new_file_name):
-        os.remove(new_file_name)
-    return edited_content
-
-
-def _generate_optimized_replacements(
-    path: str, original_content: str, edited_content: str
-) -> list[FileReplacement]:
-    matcher = difflib.SequenceMatcher(None, original_content, edited_content)
-    hunks = _group_opcodes_into_hunks(matcher.get_opcodes())
-    replacements = []
-    for hunk in hunks:
-        replacement = _create_replacement_from_hunk(
-            path, original_content, edited_content, hunk
-        )
-        if replacement:
-            replacements.append(replacement)
-    return replacements
-
-
-def _group_opcodes_into_hunks(opcodes, merge_threshold=200):
-    """
-    Groups opcodes into hunks.
-    'equal' blocks smaller than merge_threshold are treated as context (glue) within a hunk.
-    """
-    hunks = []
-    current_hunk = []
-    for tag, i1, i2, j1, j2 in opcodes:
-        if tag == "equal":
-            if i2 - i1 < merge_threshold:
-                if current_hunk:
-                    current_hunk.append((tag, i1, i2, j1, j2))
-            else:
-                if current_hunk:
-                    hunks.append(current_hunk)
-                    current_hunk = []
-        else:
-            current_hunk.append((tag, i1, i2, j1, j2))
-    if current_hunk:
-        hunks.append(current_hunk)
-    return hunks
-
-
-def _create_replacement_from_hunk(
-    path: str, original_content: str, edited_content: str, hunk: list
-) -> FileReplacement | None:
-    # Trim leading/trailing 'equal' opcodes
-    while hunk and hunk[0][0] == "equal":
-        hunk.pop(0)
-    while hunk and hunk[-1][0] == "equal":
-        hunk.pop()
-    if not hunk:
-        return None
-    # Determine range of modification
-    i_start = hunk[0][1]
-    i_end = hunk[-1][2]
-    j_start = hunk[0][3]
-    j_end = hunk[-1][4]
-    base_old_text = original_content[i_start:i_end]
-    base_new_text = edited_content[j_start:j_end]
-    if base_old_text == base_new_text:
-        return None
-    # Expand context
-    start, end = _expand_context_for_uniqueness(original_content, i_start, i_end)
-    start, end = _expand_to_word_boundary(original_content, start, end)
-    final_old_text = original_content[start:end]
-    # Reconstruct new text
-    prefix = original_content[start:i_start]
-    suffix = original_content[i_end:end]
-    final_new_text = prefix + base_new_text + suffix
-    if final_old_text == final_new_text:
-        return None
-    return {
-        "path": path,
-        "old_text": final_old_text,
-        "new_text": final_new_text,
-        "count": 1,
-    }
-
-
-def _expand_context_for_uniqueness(
-    content: str, start: int, end: int
-) -> tuple[int, int]:
-    """Expands the range [start, end] until the substring content[start:end] is unique."""
-    while content.count(content[start:end]) > 1:
-        if start == 0 and end == len(content):
-            break
-        if start > 0:
-            start -= 1
-        if end < len(content):
-            end += 1
-    return start, end
-
-
-def _expand_to_word_boundary(content: str, start: int, end: int) -> tuple[int, int]:
-    """Expands the range [start, end] outwards to the nearest whitespace boundaries."""
-
-    def is_boundary(char):
-        return char.isspace()
-
-    while start > 0 and not is_boundary(content[start - 1]):
-        start -= 1
-    while end < len(content) and not is_boundary(content[end]):
-        end += 1
-    return start, end

zrb/task/llm/file_tool_model.py

@@ -1,57 +0,0 @@
-import sys
-from typing import Literal
-
-if sys.version_info >= (3, 12):
-    from typing import NotRequired, TypedDict
-else:
-    from typing_extensions import NotRequired, TypedDict
-
-
-class FileToRead(TypedDict):
-    """
-    Configuration for reading a file or file section.
-
-    Attributes:
-        path (str): Absolute or relative path to the file
-        start_line (int | None): Starting line number (1-based, inclusive).
-            If None, reads from beginning.
-        end_line (int | None): Ending line number (1-based, exclusive). If None, reads to end.
-    """
-
-    path: str
-    start_line: NotRequired[int | None]
-    end_line: NotRequired[int | None]
-
-
-class FileToWrite(TypedDict):
-    """
-    Configuration for writing content to a file.
-
-    Attributes:
-        path (str): Absolute or relative path where file will be written.
-        content (str): Content to write. CRITICAL: For JSON, ensure all special characters
-            in this string are properly escaped.
-        mode (str): Mode for writing:
-            'w' (overwrite, default), 'a' (append), 'x' (create exclusively).
-    """
-
-    path: str
-    content: str
-    mode: NotRequired[Literal["w", "wt", "tw", "a", "at", "ta", "x", "xt", "tx"]]
-
-
-class FileReplacement(TypedDict):
-    """
-    Configuration for a single text replacement operation in a file.
-
-    Attributes:
-        path (str): Absolute or relative path to the file
-        old_text (str): Exact text to find and replace (must match file content exactly)
-        new_text (str): New text to replace with
-        count (int): Optional. Number of occurrences to replace. Defaults to -1 (all).
-    """
-
-    path: str
-    old_text: str
-    new_text: str
-    count: NotRequired[int]