...

docs/docs/rhai/buildah_module_tests.md

@@ -0,0 +1,105 @@
+# Buildah Module Tests
+
+This document describes the test scripts for the Buildah module in the SAL library. These tests verify the functionality of the Buildah module's container and image operations.
+
+## Test Structure
+
+The tests are organized into three main scripts:
+
+1. **Builder Pattern** (`01_builder_pattern.rhai`): Tests for the Builder pattern, including creating containers, running commands, and working with container content.
+2. **Image Operations** (`02_image_operations.rhai`): Tests for image-related operations like pulling, tagging, listing, and removing images.
+3. **Container Operations** (`03_container_operations.rhai`): Tests for container-related operations like configuration, isolation, and content management.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/buildah/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/buildah/01_builder_pattern.rhai
+```
+
+## Test Details
+
+### Builder Pattern Test
+
+The Builder Pattern test (`01_builder_pattern.rhai`) verifies the following functions:
+
+- `bah_new`: Creating a new Builder with a container from a specified image
+- Builder properties: `container_id`, `name`, `image`, `debug_mode`
+- `run`: Running commands in the container
+- `write_content`: Writing content to files in the container
+- `read_content`: Reading content from files in the container
+- `set_entrypoint`: Setting the container's entrypoint
+- `set_cmd`: Setting the container's command
+- `add`: Adding files to the container
+- `copy`: Copying files to the container
+- `commit`: Committing the container to an image
+- `remove`: Removing the container
+- `images`: Listing images
+- `image_remove`: Removing images
+
+### Image Operations Test
+
+The Image Operations test (`02_image_operations.rhai`) verifies the following functions:
+
+- `image_pull`: Pulling images from registries
+- `image_tag`: Tagging images
+- `images`: Listing images
+- `build`: Building images from Dockerfiles
+- `image_remove`: Removing images
+
+The test creates a temporary directory with a Dockerfile for testing the build functionality.
+
+### Container Operations Test
+
+The Container Operations test (`03_container_operations.rhai`) verifies the following functions:
+
+- `reset`: Resetting a Builder by removing its container
+- `config`: Configuring container properties
+- `run_with_isolation`: Running commands with isolation
+- Content operations: Creating and executing scripts in the container
+- `commit` with options: Committing a container with additional configuration
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Checks if Buildah is available before running tests
+2. Skips tests if Buildah is not available
+3. Contains simplified versions of each test
+4. Runs each test in a try/catch block to handle errors
+5. Catches and reports any errors
+6. Provides a summary of passed, failed, and skipped tests
+
+## Buildah Requirements
+
+These tests require the Buildah tool to be installed and available in the system's PATH. The tests will check for Buildah's availability and skip the tests if it's not found, rather than failing.
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/buildah` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Buildah module:
+
+1. Always check if Buildah is available before running tests
+2. Use unique names for containers and images to avoid conflicts
+3. Clean up any containers, images, or files created during testing
+4. Use assertions to verify expected behavior
+5. Print clear messages about what's being tested
+6. Handle errors gracefully
+7. Make tests independent of each other
+8. Keep tests focused on specific functionality

docs/docs/rhai/ci_workflow.md

@@ -0,0 +1,71 @@
+# Continuous Integration for Rhai Tests
+
+This document describes the continuous integration (CI) workflow for running Rhai tests in the SAL library.
+
+## GitHub Actions Workflow
+
+The SAL project includes a GitHub Actions workflow that automatically runs all Rhai tests whenever changes are made to relevant files. This ensures that the Rhai integration continues to work correctly as the codebase evolves.
+
+### Workflow File
+
+The workflow is defined in `.github/workflows/rhai-tests.yml`.
+
+### Trigger Events
+
+The workflow runs automatically when:
+
+1. Changes are pushed to the `main` or `master` branch that affect:
+   - Rhai test scripts (`src/rhai_tests/**`)
+   - Rhai module code (`src/rhai/**`)
+   - Git module code (`src/git/**`)
+   - OS module code (`src/os/**`)
+   - The test runner script (`run_rhai_tests.sh`)
+   - The workflow file itself (`.github/workflows/rhai-tests.yml`)
+
+2. A pull request is opened or updated that affects the same files.
+
+3. The workflow is manually triggered using the GitHub Actions interface.
+
+### Workflow Steps
+
+The workflow performs the following steps:
+
+1. **Checkout Code**: Checks out the repository code.
+2. **Set up Rust**: Installs the Rust toolchain.
+3. **Cache Dependencies**: Caches Rust dependencies to speed up builds.
+4. **Build herodo**: Builds the `herodo` binary used to run Rhai scripts.
+5. **Install Dependencies**: Installs system dependencies like Git and curl.
+6. **Run Rhai Tests**: Runs the `run_rhai_tests.sh` script to execute all Rhai tests.
+7. **Check for Failures**: Verifies that all tests passed.
+
+### Test Results
+
+The workflow will fail if any Rhai test fails. This prevents changes that break the Rhai integration from being merged.
+
+## Local Testing
+
+Before pushing changes, you can run the same tests locally using the `run_rhai_tests.sh` script:
+
+```bash
+./run_rhai_tests.sh
+```
+
+This will produce the same test results as the CI workflow, allowing you to catch and fix issues before pushing your changes.
+
+## Logs
+
+The test runner script creates a log file (`run_rhai_tests.log`) that contains the output of all tests. This log is used by the CI workflow to check for test failures.
+
+## Adding New Tests
+
+When adding new tests, make sure they are included in the appropriate module's test runner script (`run_all_tests.rhai`). The CI workflow will automatically run the new tests.
+
+## Troubleshooting
+
+If the CI workflow fails, check the GitHub Actions logs for details. Common issues include:
+
+1. **Missing Dependencies**: Ensure all required dependencies are installed.
+2. **Test Failures**: Fix any failing tests.
+3. **Build Errors**: Fix any errors in the Rust code.
+
+If you need to modify the workflow, edit the `.github/workflows/rhai-tests.yml` file.

docs/docs/rhai/git_module_tests.md

@@ -0,0 +1,81 @@
+# Git Module Tests
+
+This document describes the test scripts for the Git module in the SAL library. These tests verify the functionality of the Git module's repository management and Git operations.
+
+## Test Structure
+
+The tests are organized into two main scripts:
+
+1. **Basic Git Operations** (`01_git_basic.rhai`): Tests basic Git functionality like creating a GitTree, listing repositories, finding repositories, and cloning repositories.
+2. **Git Repository Operations** (`02_git_operations.rhai`): Tests Git operations like pull, reset, commit, and push.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/git/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/git/01_git_basic.rhai
+```
+
+## Test Details
+
+### Basic Git Operations Test
+
+The basic Git operations test (`01_git_basic.rhai`) verifies the following functions:
+
+- `git_tree_new`: Creating a GitTree
+- `list`: Listing repositories in a GitTree
+- `find`: Finding repositories matching a pattern
+- `get`: Getting or cloning a repository
+- `path`: Getting the path of a repository
+- `has_changes`: Checking if a repository has changes
+
+The test creates a temporary directory, performs operations on it, and then cleans up after itself.
+
+### Git Repository Operations Test
+
+The Git repository operations test (`02_git_operations.rhai`) verifies the following functions:
+
+- `pull`: Pulling changes from a remote repository
+- `reset`: Resetting local changes
+- `commit`: Committing changes (method existence only)
+- `push`: Pushing changes to a remote repository (method existence only)
+
+Note: The test does not actually commit or push changes to avoid modifying remote repositories. It only verifies that the methods exist and can be called.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Contains simplified versions of each test
+2. Runs each test in a try/catch block to handle errors
+3. Catches and reports any errors
+4. Provides a summary of passed and failed tests
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/git` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Git module:
+
+1. Always clean up temporary files and directories
+2. Use assertions to verify expected behavior
+3. Print clear messages about what's being tested
+4. Handle errors gracefully
+5. Make tests independent of each other
+6. Avoid tests that modify remote repositories
+7. Keep tests focused on specific functionality

docs/docs/rhai/index.md

@@ -0,0 +1,85 @@
+# Rhai Scripting in SAL
+
+This documentation covers the Rhai scripting integration in the SAL (System Abstraction Layer) library.
+
+## Overview
+
+SAL provides integration with the [Rhai scripting language](https://rhai.rs/), allowing you to use SAL's functionality in scripts. This enables automation of system tasks, testing, and more complex operations without having to write Rust code.
+
+## Modules
+
+SAL exposes the following modules to Rhai scripts:
+
+- [OS Module](os_module_tests.md): File system operations, downloads, and package management
+- Process Module: Process management and command execution
+- Git Module: Git repository operations
+- Text Module: Text processing utilities
+- Buildah Module: Container image building
+- Nerdctl Module: Container runtime operations
+- RFS Module: Remote file system operations
+- Redis Client Module: Redis database connection and operations
+- PostgreSQL Client Module: PostgreSQL database connection and operations
+
+## Running Rhai Scripts
+
+You can run Rhai scripts using the `herodo` binary:
+
+```bash
+herodo --path path/to/script.rhai
+```
+
+## Testing
+
+SAL includes test scripts for verifying the functionality of its Rhai integration. These tests are located in the `src/rhai_tests` directory and are organized by module.
+
+- [OS Module Tests](os_module_tests.md): Tests for file system, download, and package management operations
+- [Git Module Tests](git_module_tests.md): Tests for Git repository management and operations
+- [Process Module Tests](process_module_tests.md): Tests for command execution and process management
+- [Redis Client Module Tests](redisclient_module_tests.md): Tests for Redis connection and operations
+- [PostgreSQL Client Module Tests](postgresclient_module_tests.md): Tests for PostgreSQL connection and operations
+- [Text Module Tests](text_module_tests.md): Tests for text manipulation, normalization, replacement, and template rendering
+- [Buildah Module Tests](buildah_module_tests.md): Tests for container and image operations
+- [Nerdctl Module Tests](nerdctl_module_tests.md): Tests for container and image operations using nerdctl
+- [RFS Module Tests](rfs_module_tests.md): Tests for remote filesystem operations and filesystem layers
+- [Running Tests](running_tests.md): Instructions for running all Rhai tests
+- [CI Workflow](ci_workflow.md): Continuous integration workflow for Rhai tests
+
+## Examples
+
+For examples of how to use SAL's Rhai integration, see the `examples` directory in the project root. These examples demonstrate various features and use cases.
+
+## Writing Your Own Scripts
+
+When writing Rhai scripts that use SAL:
+
+1. Import the necessary modules (they're automatically registered)
+2. Use the functions provided by each module
+3. Handle errors appropriately
+4. Clean up resources when done
+
+Example:
+
+```rhai
+// Simple example of using the OS module
+let test_dir = "my_test_dir";
+mkdir(test_dir);
+
+if exist(test_dir) {
+    print(`Directory ${test_dir} created successfully`);
+
+    // Create a file
+    let test_file = test_dir + "/test.txt";
+    file_write(test_file, "Hello, world!");
+
+    // Read the file
+    let content = file_read(test_file);
+    print(`File content: ${content}`);
+
+    // Clean up
+    delete(test_dir);
+}
+```
+
+## API Reference
+
+For detailed information about the functions available in each module, refer to the module-specific documentation.

docs/docs/rhai/nerdctl_module_tests.md

@@ -0,0 +1,116 @@
+# Nerdctl Module Tests
+
+This document describes the test scripts for the Nerdctl module in the SAL library. These tests verify the functionality of the Nerdctl module's container and image operations.
+
+## Test Structure
+
+The tests are organized into three main scripts:
+
+1. **Container Operations** (`01_container_operations.rhai`): Tests for basic container operations like creating, running, executing commands, and removing containers.
+2. **Image Operations** (`02_image_operations.rhai`): Tests for image-related operations like pulling, tagging, listing, building, and removing images.
+3. **Container Builder Pattern** (`03_container_builder.rhai`): Tests for the Container Builder pattern, which provides a fluent interface for configuring and running containers.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/nerdctl/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/nerdctl/01_container_operations.rhai
+```
+
+## Test Details
+
+### Container Operations Test
+
+The Container Operations test (`01_container_operations.rhai`) verifies the following functions:
+
+- `nerdctl_container_new`: Creating a new Container
+- Container properties: `name`, `container_id`, `image`, `detach`
+- `with_image`: Setting the container image
+- `with_detach`: Setting detach mode
+- `with_env` and `with_envs`: Setting environment variables
+- `with_port` and `with_ports`: Setting port mappings
+- `with_volume`: Setting volume mounts
+- `with_cpu_limit` and `with_memory_limit`: Setting resource limits
+- `run`: Running the container
+- `exec`: Executing commands in the container
+- `logs`: Getting container logs
+- `stop`: Stopping the container
+- `remove`: Removing the container
+
+### Image Operations Test
+
+The Image Operations test (`02_image_operations.rhai`) verifies the following functions:
+
+- `nerdctl_image_pull`: Pulling images from registries
+- `nerdctl_images`: Listing images
+- `nerdctl_image_tag`: Tagging images
+- `nerdctl_image_build`: Building images from Dockerfiles
+- `nerdctl_run_with_name`: Running containers from images
+- `nerdctl_stop` and `nerdctl_remove`: Stopping and removing containers
+- `nerdctl_image_remove`: Removing images
+
+The test creates a temporary directory with a Dockerfile for testing the build functionality.
+
+### Container Builder Pattern Test
+
+The Container Builder Pattern test (`03_container_builder.rhai`) verifies the following functions:
+
+- `nerdctl_container_from_image`: Creating a container from an image
+- `reset`: Resetting container configuration
+- `with_detach`: Setting detach mode
+- `with_ports`: Setting multiple port mappings
+- `with_volumes`: Setting multiple volume mounts
+- `with_envs`: Setting multiple environment variables
+- `with_network`: Setting network
+- `with_cpu_limit` and `with_memory_limit`: Setting resource limits
+- `run`: Running the container
+- `exec`: Executing commands in the container
+- `stop`: Stopping the container
+- `remove`: Removing the container
+
+The test also verifies that environment variables and volume mounts work correctly by writing and reading files between the container and the host.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Checks if nerdctl is available before running tests
+2. Skips tests if nerdctl is not available
+3. Contains simplified versions of each test
+4. Runs each test in a try/catch block to handle errors
+5. Catches and reports any errors
+6. Provides a summary of passed, failed, and skipped tests
+
+## Nerdctl Requirements
+
+These tests require the nerdctl tool to be installed and available in the system's PATH. The tests will check for nerdctl's availability and skip the tests if it's not found, rather than failing.
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/nerdctl` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Nerdctl module:
+
+1. Always check if nerdctl is available before running tests
+2. Use unique names for containers and images to avoid conflicts
+3. Clean up any containers, images, or files created during testing
+4. Use assertions to verify expected behavior
+5. Print clear messages about what's being tested
+6. Handle errors gracefully
+7. Make tests independent of each other
+8. Keep tests focused on specific functionality

docs/docs/rhai/os_module_tests.md

@@ -0,0 +1,105 @@
+# OS Module Tests
+
+This document describes the test scripts for the OS module in the SAL library. These tests verify the functionality of the OS module's file system operations, download capabilities, and package management features.
+
+## Test Structure
+
+The tests are organized into three main scripts:
+
+1. **File Operations** (`01_file_operations.rhai`): Tests file system operations like creating, reading, writing, and manipulating files and directories.
+2. **Download Operations** (`02_download_operations.rhai`): Tests downloading files from the internet and related operations.
+3. **Package Operations** (`03_package_operations.rhai`): Tests package management functionality.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency on the `run_script` function.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+# Assume that you have the herodo binary/built into your system
+herodo --path src/rhai_tests/os/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+# Assume that you have the herodo binary/built into your system
+herodo --path src/rhai_tests/os/01_file_operations.rhai
+```
+
+## Test Details
+
+### File Operations Test
+
+The file operations test (`01_file_operations.rhai`) verifies the following functions:
+
+- `mkdir`: Creating directories
+- `file_write`: Writing content to files
+- `file_read`: Reading content from files
+- `file_size`: Getting file size
+- `file_write_append`: Appending content to files
+- `copy`: Copying files
+- `mv`: Moving files
+- `find_file`: Finding a single file matching a pattern
+- `find_files`: Finding multiple files matching a pattern
+- `find_dir`: Finding a single directory matching a pattern
+- `find_dirs`: Finding multiple directories matching a pattern
+- `chdir`: Changing the current working directory
+- `rsync`: Synchronizing directories
+- `delete`: Deleting files and directories
+- `exist`: Checking if files or directories exist
+
+The test creates a temporary directory structure, performs operations on it, and then cleans up after itself.
+
+### Download Operations Test
+
+The download operations test (`02_download_operations.rhai`) verifies the following functions:
+
+- `which`: Checking if a command exists in the system PATH
+- `cmd_ensure_exists`: Ensuring commands exist
+- `download_file`: Downloading a file from a URL
+- `chmod_exec`: Making a file executable
+
+The test downloads a small file from GitHub, verifies its content, and then cleans up.
+
+### Package Operations Test
+
+The package operations test (`03_package_operations.rhai`) verifies the following functions:
+
+- `package_platform`: Getting the current platform
+- `package_set_debug`: Setting debug mode for package operations
+- `package_is_installed`: Checking if a package is installed
+- `package_search`: Searching for packages
+- `package_list`: Listing installed packages
+
+Note: The test does not verify `package_install`, `package_remove`, `package_update`, or `package_upgrade` as these require root privileges and could modify the system state.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Contains simplified versions of each test
+2. Runs each test in a try/catch block to handle errors
+3. Catches and reports any errors
+4. Provides a summary of passed and failed tests
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/os` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the OS module:
+
+1. Always clean up temporary files and directories
+2. Use assertions to verify expected behavior
+3. Print clear messages about what's being tested
+4. Handle errors gracefully
+5. Make tests independent of each other
+6. Avoid tests that require root privileges when possible
+7. Keep tests focused on specific functionality

docs/docs/rhai/postgresclient_module_tests.md

@@ -0,0 +1,188 @@
+# PostgreSQL Client Module Tests
+
+The PostgreSQL client module provides functions for connecting to and interacting with PostgreSQL databases. These tests verify the functionality of the module.
+
+## PostgreSQL Client Features
+
+The PostgreSQL client module provides the following features:
+
+1. **Basic PostgreSQL Operations**: Execute queries, fetch results, etc.
+2. **Connection Management**: Automatic connection handling and reconnection
+3. **Builder Pattern for Configuration**: Flexible configuration with authentication support
+4. **PostgreSQL Installer**: Install and configure PostgreSQL using nerdctl
+5. **Database Management**: Create databases and execute SQL scripts
+
+## Prerequisites
+
+For basic PostgreSQL operations:
+- PostgreSQL server must be running and accessible
+- Environment variables should be set for connection details:
+  - `POSTGRES_HOST`: PostgreSQL server host (default: localhost)
+  - `POSTGRES_PORT`: PostgreSQL server port (default: 5432)
+  - `POSTGRES_USER`: PostgreSQL username (default: postgres)
+  - `POSTGRES_PASSWORD`: PostgreSQL password
+  - `POSTGRES_DB`: PostgreSQL database name (default: postgres)
+
+For PostgreSQL installer:
+- nerdctl must be installed and working
+- Docker images must be accessible
+- Sufficient permissions to create and manage containers
+
+## Test Files
+
+### 01_postgres_connection.rhai
+
+Tests basic PostgreSQL connection and operations:
+
+- Connecting to PostgreSQL
+- Pinging the server
+- Creating a table
+- Inserting data
+- Querying data
+- Dropping a table
+- Resetting the connection
+
+### 02_postgres_installer.rhai
+
+Tests PostgreSQL installer functionality:
+
+- Installing PostgreSQL using nerdctl
+- Creating a database
+- Executing SQL scripts
+- Checking if PostgreSQL is running
+
+### run_all_tests.rhai
+
+Runs all PostgreSQL client module tests and provides a summary of the results.
+
+## Running the Tests
+
+You can run the tests using the `herodo` command:
+
+```bash
+herodo --path src/rhai_tests/postgresclient/run_all_tests.rhai
+```
+
+Or run individual tests:
+
+```bash
+herodo --path src/rhai_tests/postgresclient/01_postgres_connection.rhai
+```
+
+## Available Functions
+
+### Connection Functions
+
+- `pg_connect()`: Connect to PostgreSQL using environment variables
+- `pg_ping()`: Ping the PostgreSQL server to check if it's available
+- `pg_reset()`: Reset the PostgreSQL client connection
+
+### Query Functions
+
+- `pg_execute(query)`: Execute a query and return the number of affected rows
+- `pg_query(query)`: Execute a query and return the results as an array of maps
+- `pg_query_one(query)`: Execute a query and return a single row as a map
+
+### Installer Functions
+
+- `pg_install(container_name, version, port, username, password)`: Install PostgreSQL using nerdctl
+- `pg_create_database(container_name, db_name)`: Create a new database in PostgreSQL
+- `pg_execute_sql(container_name, db_name, sql)`: Execute a SQL script in PostgreSQL
+- `pg_is_running(container_name)`: Check if PostgreSQL is running
+
+## Authentication Support
+
+The PostgreSQL client module will support authentication using the builder pattern in a future update.
+
+The backend implementation is ready, but the Rhai bindings are still in development.
+
+When implemented, the builder pattern will support the following configuration options:
+
+- Host: Set the PostgreSQL host
+- Port: Set the PostgreSQL port
+- User: Set the PostgreSQL username
+- Password: Set the PostgreSQL password
+- Database: Set the PostgreSQL database name
+- Application name: Set the application name
+- Connection timeout: Set the connection timeout in seconds
+- SSL mode: Set the SSL mode
+
+## Example Usage
+
+### Basic PostgreSQL Operations
+
+```rust
+// Connect to PostgreSQL
+if (pg_connect()) {
+    print("Connected to PostgreSQL!");
+
+    // Create a table
+    let create_table_query = "CREATE TABLE IF NOT EXISTS test_table (id SERIAL PRIMARY KEY, name TEXT)";
+    pg_execute(create_table_query);
+
+    // Insert data
+    let insert_query = "INSERT INTO test_table (name) VALUES ('test')";
+    pg_execute(insert_query);
+
+    // Query data
+    let select_query = "SELECT * FROM test_table";
+    let results = pg_query(select_query);
+
+    // Process results
+    for (result in results) {
+        print(`ID: ${result.id}, Name: ${result.name}`);
+    }
+
+    // Clean up
+    let drop_query = "DROP TABLE test_table";
+    pg_execute(drop_query);
+}
+```
+
+### PostgreSQL Installer
+
+```rust
+// Install PostgreSQL
+let container_name = "my-postgres";
+let postgres_version = "15";
+let postgres_port = 5432;
+let postgres_user = "myuser";
+let postgres_password = "mypassword";
+
+if (pg_install(container_name, postgres_version, postgres_port, postgres_user, postgres_password)) {
+    print("PostgreSQL installed successfully!");
+
+    // Create a database
+    let db_name = "mydb";
+    if (pg_create_database(container_name, db_name)) {
+        print(`Database '${db_name}' created successfully!`);
+
+        // Execute a SQL script
+        let create_table_sql = `
+            CREATE TABLE users (
+                id SERIAL PRIMARY KEY,
+                name TEXT NOT NULL,
+                email TEXT UNIQUE NOT NULL
+            );
+        `;
+
+        let result = pg_execute_sql(container_name, db_name, create_table_sql);
+        print("Table created successfully!");
+
+        // Insert data
+        let insert_sql = "#
+            INSERT INTO users (name, email) VALUES
+            ('John Doe', 'john@example.com'),
+            ('Jane Smith', 'jane@example.com');
+        #";
+
+        result = pg_execute_sql(container_name, db_name, insert_sql);
+        print("Data inserted successfully!");
+
+        // Query data
+        let query_sql = "SELECT * FROM users;";
+        result = pg_execute_sql(container_name, db_name, query_sql);
+        print(`Query result: ${result}`);
+    }
+}
+```

docs/docs/rhai/process_module_tests.md

@@ -0,0 +1,79 @@
+# Process Module Tests
+
+This document describes the test scripts for the Process module in the SAL library. These tests verify the functionality of the Process module's command execution and process management features.
+
+## Test Structure
+
+The tests are organized into two main scripts:
+
+1. **Command Execution** (`01_command_execution.rhai`): Tests command execution functions like `run()` and `which()`.
+2. **Process Management** (`02_process_management.rhai`): Tests process management functions like `process_list()` and `process_get()`.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/process/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/process/01_command_execution.rhai
+```
+
+## Test Details
+
+### Command Execution Test
+
+The command execution test (`01_command_execution.rhai`) verifies the following functions:
+
+- `run()`: Running shell commands
+- `run().do()`: Executing commands and capturing output
+- `run().silent()`: Running commands without displaying output
+- `run().ignore_error()`: Running commands that might fail without throwing errors
+- `which()`: Finding the path of an executable
+
+The test runs various commands and verifies their output and exit status.
+
+### Process Management Test
+
+The process management test (`02_process_management.rhai`) verifies the following functions:
+
+- `process_list()`: Listing running processes
+- `process_get()`: Getting information about a specific process
+- Process properties: Accessing process information like PID, name, CPU usage, and memory usage
+
+The test lists running processes and verifies that their properties are accessible.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Contains simplified versions of each test
+2. Runs each test in a try/catch block to handle errors
+3. Catches and reports any errors
+4. Provides a summary of passed and failed tests
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/process` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Process module:
+
+1. Use assertions to verify expected behavior
+2. Print clear messages about what's being tested
+3. Handle errors gracefully
+4. Make tests independent of each other
+5. Avoid tests that could disrupt the system (e.g., killing important processes)
+6. Keep tests focused on specific functionality
+7. Clean up any resources created during testing

docs/docs/rhai/redisclient_module_tests.md

@@ -0,0 +1,125 @@
+# Redis Client Module Tests
+
+This document describes the test scripts for the Redis client module in the SAL library. These tests verify the functionality of the Redis client module's connection management and Redis operations.
+
+## Redis Client Features
+
+The Redis client module provides the following features:
+
+1. **Basic Redis Operations**: SET, GET, DEL, etc.
+2. **Hash Operations**: HSET, HGET, HGETALL, HDEL
+3. **List Operations**: RPUSH, LPUSH, LLEN, LRANGE
+4. **Connection Management**: Automatic connection handling and reconnection
+5. **Builder Pattern for Configuration**: Flexible configuration with authentication support
+
+## Test Structure
+
+The tests are organized into two main scripts:
+
+1. **Redis Connection** (`01_redis_connection.rhai`): Tests basic Redis connection and simple operations like PING, SET, GET, and DEL.
+2. **Redis Operations** (`02_redis_operations.rhai`): Tests more advanced Redis operations like hash operations (HSET, HGET, HGETALL, HDEL) and list operations (RPUSH, LLEN, LRANGE).
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/redisclient/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/redisclient/01_redis_connection.rhai
+```
+
+## Test Details
+
+### Redis Connection Test
+
+The Redis connection test (`01_redis_connection.rhai`) verifies the following functions:
+
+- `redis_ping`: Checking if the Redis server is available
+- `redis_set`: Setting a key-value pair
+- `redis_get`: Getting a value by key
+- `redis_del`: Deleting a key
+
+The test creates a temporary key, performs operations on it, and then cleans up after itself.
+
+### Redis Operations Test
+
+The Redis operations test (`02_redis_operations.rhai`) verifies the following functions:
+
+- Hash operations:
+  - `redis_hset`: Setting a field in a hash
+  - `redis_hget`: Getting a field from a hash
+  - `redis_hgetall`: Getting all fields and values from a hash
+  - `redis_hdel`: Deleting a field from a hash
+
+- List operations:
+  - `redis_rpush`: Adding elements to a list
+  - `redis_llen`: Getting the length of a list
+  - `redis_lrange`: Getting a range of elements from a list
+
+The test creates temporary keys with a unique prefix, performs operations on them, and then cleans up after itself.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Checks if Redis is available before running tests
+2. Skips tests if Redis is not available
+3. Contains simplified versions of each test
+4. Runs each test in a try/catch block to handle errors
+5. Catches and reports any errors
+6. Provides a summary of passed, failed, and skipped tests
+
+## Redis Server Requirements
+
+These tests require a Redis server to be running and accessible. The tests will attempt to connect to Redis using the following strategy:
+
+1. First, try to connect via Unix socket at `$HOME/hero/var/myredis.sock`
+2. If that fails, try to connect via TCP to `127.0.0.1` on the default Redis port (6379)
+
+If no Redis server is available, the tests will be skipped rather than failing.
+
+## Authentication Support
+
+The Redis client module will support authentication using the builder pattern in a future update.
+
+The backend implementation is ready, but the Rhai bindings are still in development.
+
+When implemented, the builder pattern will support the following configuration options:
+
+- Host: Set the Redis host
+- Port: Set the Redis port
+- Database: Set the Redis database number
+- Username: Set the Redis username (Redis 6.0+)
+- Password: Set the Redis password
+- TLS: Enable/disable TLS
+- Unix socket: Enable/disable Unix socket
+- Socket path: Set the Unix socket path
+- Connection timeout: Set the connection timeout in seconds
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/redisclient` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Redis client module:
+
+1. Always check if Redis is available before running tests
+2. Use a unique prefix for test keys to avoid conflicts
+3. Clean up any keys created during testing
+4. Use assertions to verify expected behavior
+5. Print clear messages about what's being tested
+6. Handle errors gracefully
+7. Make tests independent of each other
+8. Keep tests focused on specific functionality

docs/docs/rhai/rfs_module_tests.md

@@ -0,0 +1,113 @@
+# RFS Module Tests
+
+This document describes the test scripts for the RFS (Remote File System) module in the SAL library. These tests verify the functionality of the RFS module's mount operations and filesystem layer management.
+
+## Test Structure
+
+The tests are organized into two main scripts:
+
+1. **Mount Operations** (`01_mount_operations.rhai`): Tests for mounting, listing, and unmounting filesystems.
+2. **Filesystem Layer Operations** (`02_filesystem_layer_operations.rhai`): Tests for packing, unpacking, listing, and verifying filesystem layers.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/rfs/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/rfs/01_mount_operations.rhai
+```
+
+## Test Details
+
+### Mount Operations Test
+
+The Mount Operations test (`01_mount_operations.rhai`) verifies the following functions:
+
+- `rfs_mount`: Mounting a filesystem
+  - Tests mounting a local directory with options
+  - Verifies mount properties (ID, source, target, type)
+
+- `rfs_list_mounts`: Listing mounted filesystems
+  - Tests listing all mounts
+  - Verifies that the mounted filesystem is in the list
+
+- `rfs_get_mount_info`: Getting information about a mounted filesystem
+  - Tests getting information about a specific mount
+  - Verifies that the mount information is correct
+
+- `rfs_unmount`: Unmounting a specific filesystem
+  - Tests unmounting a specific mount
+  - Verifies that the mount is no longer available
+
+- `rfs_unmount_all`: Unmounting all filesystems
+  - Tests unmounting all mounts
+  - Verifies that no mounts remain after the operation
+
+The test also verifies that files in the mounted filesystem are accessible and have the correct content.
+
+### Filesystem Layer Operations Test
+
+The Filesystem Layer Operations test (`02_filesystem_layer_operations.rhai`) verifies the following functions:
+
+- `rfs_pack`: Packing a directory into a filesystem layer
+  - Tests packing a directory with files and subdirectories
+  - Verifies that the output file is created
+
+- `rfs_list_contents`: Listing the contents of a filesystem layer
+  - Tests listing the contents of a packed filesystem layer
+  - Verifies that the list includes all expected files
+
+- `rfs_verify`: Verifying a filesystem layer
+  - Tests verifying a packed filesystem layer
+  - Verifies that the layer is valid
+
+- `rfs_unpack`: Unpacking a filesystem layer
+  - Tests unpacking a filesystem layer to a directory
+  - Verifies that all files are unpacked correctly with the right content
+
+The test creates a directory structure with files, packs it into a filesystem layer, and then unpacks it to verify the integrity of the process.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Checks if RFS is available before running tests
+2. Skips tests if RFS is not available
+3. Contains simplified versions of each test
+4. Runs each test in a try/catch block to handle errors
+5. Catches and reports any errors
+6. Provides a summary of passed, failed, and skipped tests
+
+## RFS Requirements
+
+These tests require the RFS tool to be installed and available in the system's PATH. The tests will check for RFS's availability and skip the tests if it's not found, rather than failing.
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/rfs` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the RFS module:
+
+1. Always check if RFS is available before running tests
+2. Clean up any mounts before and after testing
+3. Use unique names for test directories and files to avoid conflicts
+4. Clean up any files or directories created during testing
+5. Use assertions to verify expected behavior
+6. Print clear messages about what's being tested
+7. Handle errors gracefully
+8. Make tests independent of each other
+9. Keep tests focused on specific functionality

docs/docs/rhai/running_tests.md

@@ -0,0 +1,76 @@
+# Running Rhai Tests
+
+This document describes how to run the Rhai tests for the SAL library.
+
+## Test Structure
+
+The Rhai tests are organized by module in the `src/rhai_tests` directory:
+
+- `src/rhai_tests/os/`: Tests for the OS module
+- `src/rhai_tests/git/`: Tests for the Git module
+
+Each module directory contains:
+- Individual test scripts (e.g., `01_file_operations.rhai`)
+- A test runner script (`run_all_tests.rhai`) that runs all tests for that module
+
+## Running Tests
+
+### Running All Tests
+
+To run all Rhai tests across all modules, use the provided shell script:
+
+```bash
+./run_rhai_tests.sh
+```
+
+This script:
+1. Finds all test runner scripts in the `src/rhai_tests` directory
+2. Runs each test runner
+3. Reports the results for each module
+4. Provides a summary of all test results
+
+The script will exit with code 0 if all tests pass, or code 1 if any tests fail.
+
+### Running Tests for a Specific Module
+
+To run tests for a specific module, use the `herodo` command with the module's test runner:
+
+```bash
+herodo --path src/rhai_tests/os/run_all_tests.rhai
+```
+
+### Running Individual Tests
+
+To run a specific test, use the `herodo` command with the test script:
+
+```bash
+herodo --path src/rhai_tests/os/01_file_operations.rhai
+```
+
+## Test Output
+
+The test output includes:
+- Information about what's being tested
+- Success or failure messages for each test
+- A summary of test results
+
+Successful tests are indicated with a checkmark (✓), while failed tests show an error message.
+
+## Adding New Tests
+
+When adding new tests:
+
+1. Create a new test script in the appropriate module directory
+2. Update the module's test runner script to include the new test
+3. Update the module's documentation to describe the new test
+
+The `run_rhai_tests.sh` script will automatically find and run the new tests as long as they're included in a module's test runner script.
+
+## Troubleshooting
+
+If tests fail, check the following:
+
+1. Make sure the `herodo` binary is in your PATH
+2. Verify that the test scripts have the correct permissions
+3. Check for any dependencies required by the tests (e.g., `git` for Git module tests)
+4. Look for specific error messages in the test output

docs/docs/rhai/text_module_tests.md

@@ -0,0 +1,129 @@
+# Text Module Tests
+
+This document describes the test scripts for the Text module in the SAL library. These tests verify the functionality of the Text module's text manipulation, normalization, replacement, and template rendering capabilities.
+
+## Test Structure
+
+The tests are organized into four main scripts:
+
+1. **Text Indentation** (`01_text_indentation.rhai`): Tests for the `dedent` and `prefix` functions.
+2. **Filename and Path Normalization** (`02_name_path_fix.rhai`): Tests for the `name_fix` and `path_fix` functions.
+3. **Text Replacement** (`03_text_replacer.rhai`): Tests for the `TextReplacer` class and its methods.
+4. **Template Rendering** (`04_template_builder.rhai`): Tests for the `TemplateBuilder` class and its methods.
+
+Additionally, there's a runner script (`run_all_tests.rhai`) that executes all tests and reports results. The runner script contains simplified versions of the individual tests to avoid dependency issues.
+
+## Running the Tests
+
+To run all tests, execute the following command from the project root:
+
+```bash
+herodo --path src/rhai_tests/text/run_all_tests.rhai
+```
+
+To run individual test scripts:
+
+```bash
+herodo --path src/rhai_tests/text/01_text_indentation.rhai
+```
+
+## Test Details
+
+### Text Indentation Test
+
+The text indentation test (`01_text_indentation.rhai`) verifies the following functions:
+
+- `dedent`: Removes common leading whitespace from multiline strings
+  - Tests basic indentation removal
+  - Tests mixed indentation handling
+  - Tests preservation of empty lines
+  - Tests handling of text without indentation
+  - Tests single line indentation removal
+
+- `prefix`: Adds a specified prefix to each line of a multiline string
+  - Tests basic prefix addition
+  - Tests empty prefix handling
+  - Tests prefix addition to empty lines
+  - Tests prefix addition to single line
+  - Tests non-space prefix addition
+
+- Combination of `dedent` and `prefix` functions
+
+### Filename and Path Normalization Test
+
+The filename and path normalization test (`02_name_path_fix.rhai`) verifies the following functions:
+
+- `name_fix`: Normalizes filenames
+  - Tests basic name fixing (spaces to underscores, lowercase conversion)
+  - Tests special character handling
+  - Tests multiple special character handling
+  - Tests non-ASCII character removal
+  - Tests uppercase conversion
+
+- `path_fix`: Applies `name_fix` to the filename portion of a path
+  - Tests paths ending with `/` (directories)
+  - Tests single filename handling
+  - Tests path with filename handling
+  - Tests relative path handling
+  - Tests path with special characters in filename
+
+### Text Replacement Test
+
+The text replacement test (`03_text_replacer.rhai`) verifies the following functions:
+
+- `TextReplacer` with simple replacements
+  - Tests basic replacement
+  - Tests multiple replacements
+
+- `TextReplacer` with regex replacements
+  - Tests basic regex replacement
+  - Tests case-insensitive regex replacement
+
+- `TextReplacer` with file operations
+  - Tests `replace_file` (read file, apply replacements, return result)
+  - Tests `replace_file_to` (read file, apply replacements, write to new file)
+  - Tests `replace_file_in_place` (read file, apply replacements, write back to same file)
+
+### Template Rendering Test
+
+The template rendering test (`04_template_builder.rhai`) verifies the following functions:
+
+- `TemplateBuilder` with file template
+  - Tests basic template with string variable
+  - Tests template with multiple variables of different types
+  - Tests template with array variable
+  - Tests template with map variable
+
+- `TemplateBuilder` with file operations
+  - Tests template from file
+  - Tests `render_to_file` (render template, write to file)
+
+Note: The `template_builder_open` function expects a file path, not a string template. The test creates template files on disk for testing.
+
+## Test Runner
+
+The test runner script (`run_all_tests.rhai`) provides a framework for executing all tests and reporting results. It:
+
+1. Contains simplified versions of each test
+2. Runs each test in a try/catch block to handle errors
+3. Catches and reports any errors
+4. Provides a summary of passed and failed tests
+
+## Adding New Tests
+
+To add a new test:
+
+1. Create a new Rhai script in the `src/rhai_tests/text` directory
+2. Add a new test section to the `run_all_tests.rhai` script
+3. Update this documentation to include information about the new test
+
+## Best Practices for Writing Tests
+
+When writing tests for the Text module:
+
+1. Use the `assert_true` and `assert_eq` functions to verify expected behavior
+2. Print clear messages about what's being tested
+3. Clean up any temporary files or directories created during testing
+4. Handle errors gracefully
+5. Make tests independent of each other
+6. Keep tests focused on specific functionality