ruby-progress 1.3.4 → 1.3.6

data/README.md

@@ -2,32 +2,56 @@
 
 [![Gem Version](https://badge.fury.io/rb/ruby-progress.svg)](https://badge.fury.io/rb/ruby-progress)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![RSpec Tests](https://github.com/ttscoff/ruby-progress/actions/workflows/rspec.yml/badge.svg)](https://github.com/ttscoff/ruby-progress/actions/workflows/rspec.yml)
+<!-- [![RSpec Tests](https://github.com/ttscoff/ruby-progress/actions/workflows/rspec.yml/badge.svg)](https://github.com/ttscoff/ruby-progress/actions/workflows/rspec.yml) -->
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.5.0-ruby.svg)](https://www.ruby-lang.org/)
-[![Coverage Status](https://img.shields.io/badge/coverage-55%25-yellow.svg)](#)
+<!-- [![Coverage Status](https://img.shields.io/badge/coverage-31%25-yellow.svg)](#) -->
 
 This repository contains three different Ruby progress indicator projects: **Ripple**, **Worm**, and **Twirl**. All provide animated terminal progress indicators with different visual styles and features.
 
 ## Table of Contents
 
-- [Unified Interface](#unified-interface)
-  - [Submitting jobs to a running daemon](#submitting-jobs-to-a-running-daemon)
-- [Job result schema](#job-result-schema)
-- [Example: start a daemon and send a job (simple)](#example-start-a-daemon-and-send-a-job-simple)
-- [Ripple](#ripple)
-  - [Ripple Features](#ripple-features)
-  - [Ripple Usage](#ripple-usage)
-- [Twirl](#twirl)
-- [Worm](#worm)
-  - [Daemon mode (background indicator)](#daemon-mode-background-indicator)
-- [Requirements](#requirements)
-- [Installation](#installation)
-- [Universal Utilities](#universal-utilities)
-  - [Terminal Control](#terminal-control)
-  - [Completion Messages](#completion-messages)
-- [Development](#development)
-- [Contributing](#contributing)
-- [License](#license)
+- [Ruby Progress Indicators](#ruby-progress-indicators)
+  - [Table of Contents](#table-of-contents)
+  - [Unified Interface](#unified-interface)
+    - [Global Options](#global-options)
+    - [Stopping a backgrounded progress indicator](#stopping-a-backgrounded-progress-indicator)
+      - [Job Control Subcommands](#job-control-subcommands)
+  - [Example: background mode demo](#example-background-mode-demo)
+  - [Ripple](#ripple)
+    - [Ripple Features](#ripple-features)
+    - [Ripple Usage](#ripple-usage)
+      - [Ripple CLI examples](#ripple-cli-examples)
+      - [Ripple Command Line Options](#ripple-command-line-options)
+    - [Ripple Library Usage](#ripple-library-usage)
+  - [Twirl](#twirl)
+    - [Twirl Features](#twirl-features)
+    - [Twirl Usage](#twirl-usage)
+      - [Command Line](#command-line)
+      - [Twirl Command Line Options](#twirl-command-line-options)
+    - [Available Spinner Styles](#available-spinner-styles)
+  - [Worm](#worm)
+    - [Worm Features](#worm-features)
+    - [Worm Usage](#worm-usage)
+      - [Command Line](#command-line-1)
+      - [Daemon mode (background indicator)](#daemon-mode-background-indicator)
+      - [Worm Command Line Options](#worm-command-line-options)
+    - [Worm Library Usage](#worm-library-usage)
+    - [Animation Styles](#animation-styles)
+      - [Circles](#circles)
+      - [Blocks](#blocks)
+      - [Geometric](#geometric)
+      - [Custom Styles](#custom-styles)
+      - [Direction Control](#direction-control)
+  - [Requirements](#requirements)
+  - [Installation](#installation)
+    - [As a Gem (Recommended)](#as-a-gem-recommended)
+    - [From Source](#from-source)
+    - [Development](#development)
+  - [Universal Utilities](#universal-utilities)
+    - [Terminal Control](#terminal-control)
+    - [Completion Messages](#completion-messages)
+  - [Contributing](#contributing)
+  - [License](#license)
 
 ## Unified Interface
 
@@ -78,114 +102,86 @@ Notes:
 - The indicator clears its line on shutdown and prints the final message to STDOUT.
 - `--stop-pid` is still supported for backward compatibility, but `--stop [--pid-file FILE]` is preferred.
 
-### Submitting jobs to a running daemon
+### Stopping a backgrounded progress indicator
 
-When running a long-lived daemon (for example `prg worm --daemon`), you can submit additional commands to run and have their output displayed without disrupting the animation using the `prg job send` helper.
+When running a backgrounded progress indicator (for example `prg worm --daemon`), you can send control signals using the `prg job` command with subcommands.
 
-Basic usage:
+#### Job Control Subcommands
+
+**Stop a running daemon:**
 
 ```bash
-# Enqueue a command to the default daemon PID
-prg job send --command "./deploy-step.sh"
+# Send a stop signal to the default daemon
+prg job stop
+
+# Send a stop signal to a named daemon (uses /tmp/ruby-progress/<name>.pid)
+prg job stop --daemon-name mytask
 
-# Enqueue to a named daemon (creates /tmp/ruby-progress/<name>.pid)
-prg job send --daemon-name mytask --command "rsync -av ./dist/ user@host:/srv/app"
+# Send a stop signal with a completion message
+prg job stop --daemon-name mytask --message "Deployment complete!"
 
-# Read command from stdin (useful in scripts)
-echo "bundle exec rake db:migrate" | prg job send --stdin --daemon-name mytask
+# Send a stop signal with a checkmark
+prg job stop --daemon-name mytask --message "Build successful" --checkmark
 
-# Wait for the job result and print the job result JSON (default timeout 10s)
-prg job send --daemon-name mytask --command "./deploy-step.sh" --wait --timeout 30
+# Send a stop signal indicating an error
+prg job stop --daemon-name mytask --message "Build failed" --error
 ```
 
-You can also send control/action jobs (no shell command) to a running daemon. These are JSON payloads with an `action` key handled by the daemon's job processor. The helper supports a few common actions:
+**Check daemon status:**
 
 ```bash
-# Send a simple 'advance' action (no value)
-prg job send --daemon-name demo --advance
+# Check if a daemon is running
+prg job status --daemon-name mytask
 
-# Send a 'percent' action with a numeric value
-prg job send --daemon-name demo --percent 42
+# Check status using a PID file
+prg job status --pid-file /tmp/ruby-progress/mytask.pid
+```
 
-# Example using `fill` as a named daemon and sending percent updates
-```bash
-# Start a named fill worker (non-detaching so animation remains visible)
-prg fill --daemon-as demo --no-detach --output-lines 3 --output-position top
+**Advance a progress indicator:**
 
-# Send percent updates to the named worker
-prg job send --daemon-name demo --percent 10 --wait
-prg job send --daemon-name demo --percent 50 --wait
-prg job send --daemon-name demo --percent 100 --wait
-```
+```bash
+# Advance progress by 1 (for indicators that support it)
+prg job advance --daemon-name mytask
 
-# Or use the generic action/value pair
-prg job send --daemon-name demo --action percent --value 42
+# Advance by a specific amount
+prg job advance --daemon-name mytask --amount 10
 ```
 
-Note about stopping named daemons:
+**Backward Compatibility:**
 
-You can target named daemons directly using the `--stop-id NAME` shorthand which implies `--stop` and targets the named daemon (it is normalized to the canonical daemon name used for the PID file). This is convenient for scripts and demos. Example:
+The legacy `prg job send` command is still supported but deprecated. It functions identically to `prg job stop`:
 
 ```bash
-# Stop a named fill worker with a success message
-prg fill --stop-id demo --stop-success 'Demo finished'
+# This still works but shows a deprecation warning
+prg job send --daemon-name mytask --message "Complete!"
 ```
 
-Behavior and file layout:
-
-- Jobs are written as JSON files into the daemon's job directory, which is derived from the daemon PID file. For example, a PID file `/tmp/ruby-progress/mytask.pid` maps to the job directory `/tmp/ruby-progress/mytask.jobs`.
-- The CLI writes the job atomically by first writing a `*.json.tmp` temporary file and then renaming it to `*.json`.
-- The daemon's job processor claims jobs atomically by renaming the job file to `*.processing`, writes a `*.processing.result` JSON file when finished, and moves processed jobs to `processed-*`.
-
-This mechanism allows you to submit many commands to a single running indicator and have their output shown in reserved terminal rows while the animation continues.
-
-## Job result schema
+Alternatively, you can use the built-in `--stop` flags on the progress commands:
 
-When a job is processed the daemon writes a small JSON result file next to the claimed job with the suffix `.processing.result` containing at least these keys:
-
-- `id` - the job id (string)
-- `status` - `"done"` or `"error"`
-- `time` - epoch seconds when the job finished (integer)
-
-Depending on the job handler, additional keys may be present:
-
-- `exit_status` - the numeric process exit status (integer or nil if unknown)
-- `output` - a string with the last captured lines of output (if available)
-- `error` - an error message when `status` is `error`
-
-Example:
+```bash
+# Stop a named daemon with a success message
+prg worm --stop-id demo --stop-success 'Task completed'
 
-```json
-{
-  "id": "8a1f6c1e-4b7a-4f2c-b0a8-9e9f1c2f1a2b",
-  "status": "done",
-  "time": 1634044800,
-  "exit_status": 0,
-  "output": "Step 1 completed\nStep 2 completed"
-}
+# Stop with an error message
+prg worm --stop-id demo --stop-error 'Task failed'
 ```
 
-This file is intended for short messages and small captured output snippets (the CLI captures the last N lines). If you need larger logs, write them to a persistent file from the command itself and include a reference in the job metadata.
-
-## Example: start a daemon and send a job (simple)
-
-Below is an example script that demonstrates starting a worm daemon, sending a job, waiting for the result, and stopping the daemon.
----
+## Example: background mode demo
 
-If you want the background worker to continue writing to the same terminal (so you can visually watch the animation while your script continues), use the non-detaching background mode:
+Below is an example script that demonstrates starting a backgrounded progress indicator, doing work, and stopping it with a message.
 
 ```bash
-# Start a named worm worker that backgrounds but does not fully detach
-prg worm --daemon-as demo --no-detach
+# Start a named worm worker that runs in the background
+prg worm --daemon-as demo
 
-# In the same script or a subsequent command, enqueue a job to that worker
-prg job send --daemon-name demo --command "echo hello; sleep 1; echo done" --wait
+# Do some work in your script...
+sleep 2
 
 # Stop the worker with a success message
-prg worm --stop-id demo --stop-success "Demo finished"
+prg job stop --daemon-name demo --message "Demo finished" --checkmark
 ```
 
-Note: Non-detaching mode keeps the child process attached to the controlling TTY. That means both the worker and the invoking shell may write to the terminal and outputs can interleave.
+**Note:** Daemon mode automatically backgrounds the process using `Process.fork` and `Process.detach`, so you don't need to append `&`. The process detaches cleanly without shell job notifications.
 
 ## Ripple
 

data/bin/prg

@@ -24,14 +24,8 @@ module PrgCLI
     # Handle `job` subcommands early
     if ARGV[0] && ARGV[0].downcase == 'job'
       ARGV.shift
-      sub = ARGV.shift
-      case sub
-      when 'send'
-        JobCLI.send(ARGV)
-      else
-        puts 'job subcommands: send'
-        exit 1
-      end
+      JobCLI.run(ARGV)
+      exit
     end
     # Early scan: detect --ends flag and validate its argument before dispatching
     if (i = ARGV.index('--ends')) && ARGV[i + 1]
@@ -151,16 +145,16 @@ module PrgCLI
   # Spawn a background child but do NOT fully detach from the controlling
   # terminal. This keeps the child attached to the same TTY so animations
   # remain visible, while the parent exits immediately allowing the caller
-  # (shell or script) to continue. Use when the user requests a non-detaching
-  # background worker (e.g. `--daemon-as NAME --no-detach`).
+  # (shell or script) to continue.
   def self.backgroundize
     pid = fork
-    return unless pid
-
-    # parent: exit so the invoking shell/script continues
-    exit(0)
-
-    # child: continue without setsid/IO close so output remains on the TTY
+    if pid
+      # Parent: detach child and exit silently
+      Process.detach(pid)
+      exit(0)
+    end
+    # Child: create new process group but keep stdin/stdout/stderr
+    Process.setsid
   end
 
   # Attempt to stop processes for the given subcommand. Return true if any

data/blog-post.md

@@ -1,39 +1,154 @@
 ---
-title: "More CLI Progress Indicators: The ruby-progress Gem"
-date: 2025-10-10
+title: "Ruby Progress Indicators for Modern CLI Tools"
+date: 2025-10-15 11:00
 categories: [Ruby, CLI, Development Tools]
-tags: [ruby, cli, progress, animation, terminal]
+tags: [ruby, cli, progress, animation, terminal, daemon]
 ---
+I've been playing around with progress bars in the terminal, and I think I've
+created something genuinely useful.
 
-[ripple]: https://brettterpstra.com/2025/06/30/ripple-an-indeterminate-progress-indicator/
+Yes, I know there are multiple options
+already available for this, but I wanted something specific: a Ruby library that
+could be used for command-line scripting, with CLI executables that made it easy
+to use when scripting in *any* language --- not just Ruby.
 
-# More CLI Progress Indicators: The ruby-progress Gem
+The result is `ruby-progress`, a gem that provides four different animated
+progress indicators, each with its own visual style and use cases.
 
-The `ruby-progress` gem expands my previous work on [Ripple], adding 2 more indicator types and a new daemon mode to make it more useful in non-Ruby shell scripts.
+> If you're scripting in Ruby, I do highly recommend the TTY tools from [Piotr Murach](piotrmurach),
+such as [tty-progress](https://github.com/piotrmurach/tty-progressbar/). Piotr's
+TTY tools are much more elegant with a better Ruby API. `ruby-progress` is
+designed more for use in other shell scripts than it is for detailed Ruby
+scripting.
+{:.tip}
 
-## What is ruby-progress?
+{% gif /uploads/2025/10/ruby-progress.mp4 %}
 
-Ruby-progress provides animated progress indicators for command-line applications. Unlike traditional progress bars showing completion percentage, this gem focuses on continuous animations (indeterminate) that indicate activity - perfect for tasks with unpredictable completion times.
+## The Four Progress Indicators
 
-Three animation styles are available:
+Ripple
+: creates a wave-like effect across text, with the characters rippling
+through different visual states. It supports rainbow colors, inverse
+highlighting, and case transformations. Perfect for text-heavy operations where
+you want something more dynamic than a simple spinner.
 
-- **Ripple**: Wave-like effect across text
-- **Worm**: Moving dot pattern that crawls across the screen
-- **Twirl**: Classic spinning indicators with various symbols
+Worm
+: displays a moving dot pattern that crawls across the screen using
+Unicode characters. It includes multiple styles (circles, blocks, geometric
+shapes) and can move in any direction. Great for file operations, network
+transfers, or any continuous background task.
 
-## Quick Start
+Twirl
+: provides classic spinning indicators with over 35 different spinner
+styles --- from simple dots to complex geometric patterns. It's the most
+traditional of the four, but with way more visual variety than typical spinners.
+
+Fill : is the only determinate indicator in the bunch --- an actual progress bar
+that shows completion percentage. It can be controlled via command execution or
+updated programmatically through daemon control messages.
+
+## Installation and Quick Start
+
+Installation is straightforward:
 
 ```bash
-# Install
 gem install ruby-progress
+```
+
+All four indicators are available through a unified `prg` command:
 
+```bash
 # Basic usage
-ripple "Processing files..."
-worm --message "Loading..." --speed fast
-twirl --spinner dots
+prg ripple "Processing files..."
+prg worm --message "Loading..." --style blocks
+prg twirl --message "Working..." --style dots --speed fast
+prg fill --total 100 --report
+
+# With command execution
+prg ripple "Building..." --command "make build" --success "Build complete!" --checkmark
+```
+
+You can also use the individual commands directly: `ripple`, `worm`, `twirl`, and `fill`.
+
+## The Killer Feature: Daemon Mode
+
+Here's where things get interesting. All four indicators support daemon mode,
+which lets you run a progress indicator in the background while your scripts
+execute other commands. This is useful for complex workflows.
+
+```bash
+# Start a background spinner
+prg worm --daemon-as deployment --message "Deploying application..."
+
+# Execute your actual deployment steps
+git push production main
+kubectl apply -f manifests/
+./run-migrations.sh
+
+# Stop the spinner with a success message
+prg job stop --daemon-name deployment --message "Deployment complete!" --checkmark
+```
+
+The daemon mode uses `Process.fork` and `Process.detach`, so there are no shell
+job notifications cluttering your output. The progress indicator runs cleanly in
+the background, providing visual feedback without interfering with your script's
+execution.
+
+### Keeping Output Clean
+
+One of the challenges with daemon mode is preventing command output from
+disrupting the animation. By default, when you run a progress indicator in
+daemon mode, any STDOUT or STDERR output from commands executed in your script
+will appear on the terminal and potentially mess up the animation display.
+
+Ruby-progress handles this intelligently. When running in daemon mode, the
+animation continues on its dedicated line while your commands execute. However,
+if you want to see the output from those commands, you have options:
+
+```bash
+# Run command with animation, show output after completion
+prg ripple "Building..." --command "make build" --stdout
+
+# Stream output live while animation runs (reserves terminal rows)
+prg worm "Installing..." --command "npm install" --stdout-live --output-lines 5
+
+# Run daemon and manually capture output from your script commands
+prg worm --daemon-as build --message "Building..."
+make build > /tmp/build.log 2>&1
+prg job stop --daemon-name build --message "Build complete!" --checkmark
+cat /tmp/build.log
+```
+
+The `--stdout-live` flag is particularly useful --- it reserves a section of the
+terminal to display live command output while the animation continues above or
+below it. You control how many lines to reserve with `--output-lines` and where
+they appear with `--output-position` (above or below the animation).
+
+### Job Control Commands
+
+The `prg job` command provides subcommands for controlling background indicators:
+
+- `prg job stop` --- Stop a running daemon with an optional message
+- `prg job status` --- Check if a daemon is running and show its PID
+- `prg job advance` --- Update a fill progress bar by a specific amount
+
+```bash
+# Check if a daemon is running
+prg job status --daemon-name mytask
+
+# Advance a progress bar remotely
+prg fill --daemon-as progress --total 100
+prg job advance --daemon-name progress --amount 10
+
+# Stop with error state
+prg job stop --daemon-name mytask --message "Build failed!" --error
 ```
 
-## Ruby Integration
+{% paywall "Library and advanced usage" %}
+
+## Ruby Library Usage
+
+While the CLI is great for shell scripting, the Ruby API is just as elegant:
 
 ```ruby
 require 'ruby-progress'
@@ -44,131 +159,108 @@ RubyProgress::Ripple.progress("Processing files...") do
   upload_results
 end
 
-# Manual control
+# Manual control for complex scenarios
 worm = RubyProgress::Worm.new(
   message: "Custom task",
   style: 'blocks',
   speed: 'medium'
 )
 
-worm.animate { heavy_computation }
-```
+worm.animate do
+  heavy_computation
+  more_work
+end
 
-## Daemon Mode - The Killer Feature
+# Command execution with error handling
+RubyProgress::Twirl.new(
+  command: "bundle install",
+  message: "Installing gems...",
+  success: "Dependencies installed!",
+  error: "Installation failed",
+  checkmark: true
+).run_with_command
+```
 
-Run progress indicators in the background while your scripts execute:
+## Advanced Features Worth Knowing
 
-```bash
-# Start background indicator
-worm --daemon --pid-file /tmp/progress.pid --message "Deploying..."
+### Custom Styling and Icons
 
-# Run your actual work
-./deploy.sh
-kubectl apply -f manifests/
+All indicators support custom success and error icons:
 
-# Stop with success message
-worm --stop /tmp/progress.pid --message "Deploy complete!" --checkmark
+```bash
+prg ripple "Deploying..." \
+  --command "./deploy.sh" \
+  --success "All systems go!" \
+  --error "Houston, we have a problem" \
+  --success-icon "🚀" \
+  --error-icon "💥" \
+  --checkmark
 ```
 
-This is incredibly useful for complex deployment scripts where you want continuous visual feedback without interrupting the main process.
-
-There's a unified binary called `prg` that takes the three types as subcommands, e.g. `prg twirl --checkmark`. You can use any of them either way.
+### Visual Customization
 
-## Advanced Features
+Ripple supports rainbow colors and multiple composable styles:
 
-### Error Handling
-```ruby
-RubyProgress::Ripple.progress("Risky operation") do
-  might_fail_operation
-rescue StandardError => e
-  # Automatically stops and shows error state
-  puts "Failed: #{e.message}"
-end
+```bash
+prg ripple "Processing" --style rainbow,inverse,caps
 ```
 
-### Command Integration
-```ruby
-# Execute shell commands with progress
-RubyProgress::Worm.new(
-  command: "pg_dump mydb > backup.sql",
-  success: "Backup complete!",
-  error: "Backup failed"
-).run_with_command
-```
+Worm has directional control and custom character sets:
 
-### Visual Customization
-```ruby
-# Rainbow colors and custom styling
-RubyProgress::Ripple.progress("Colorful task",
-  rainbow: true,
-  speed: :fast,
-  format: :forward_only
-) do
-  process_with_style
-end
+```bash
+prg worm --direction rtl --style "custom=🟦🟨🟥"
 ```
 
-## Real-World Examples
+### Start/End Character Decoration
 
-### Deployment Script
+The `--ends` flag lets you wrap your progress indicator with decorative characters:
 
 ```bash
-#!/bin/bash
-worm --daemon-as deploy --message "Deploying..." &
+prg worm --message "Magic" --ends "🎯🎪" --style blocks
+prg ripple "Loading data" --ends "[]" --style rainbow
+```
 
-git push production main
-kubectl rollout status deployment/app
+### Output Capture
 
-worm --stop-id deploy --stop-success "Success!" --checkmark
-```
+When running commands, you can capture and display output:
 
-### Data Processing
-```ruby
-def import_large_csv(file)
-  RubyProgress::Ripple.progress("Importing #{File.basename(file)}...") do
-    CSV.foreach(file, headers: true) { |row| User.create!(row.to_h) }
-  end
-end
-```
+```bash
+# Show command output after completion
+prg ripple "Building..." --command "make build" --stdout
 
-### Rake Tasks
-```ruby
-task :backup do
-  RubyProgress::Worm.new(
-    command: "tar -czf backup.tar.gz app/",
-    success: "Backup created successfully!"
-  ).run_with_command
-end
+# Display live output with reserved terminal rows
+prg worm --command "npm install" --output-lines 5 --output-position above
 ```
+{% endpaywall %}
+
+## Real-World Use Cases
+
+**Deployment Scripts**: Show continuous progress during multi-step deployments
+without blocking command output.
+
+**Data Processing**: Provide visual feedback during long-running data imports or
+transformations.
 
-## Why ruby-progress?
+**Build Systems**: Integrate into Rake or Make tasks to show progress during compilation.
 
-- **Simple API**: Works in Ruby code and shell scripts
-- **Visual Appeal**: Engaging animations beyond basic spinners
-- **Unique Daemon Mode**: Background progress indicators
-- **Production Ready**: 84.55% test coverage, 113 test examples, zero failures
-- **Cross-Platform**: Linux, macOS, Windows support
-- **Reliable**: Comprehensive error handling and edge case coverage
+**CI/CD Pipelines**: Add visual indicators to pipeline scripts for better monitoring.
 
-## Installation & First Steps
+**System Administration**: Show progress during backups, database dumps, or file
+synchronization.
 
-1. **Install**: `gem install ruby-progress`
-2. **Test CLI**: `ripple "Hello World!"`
-3. **Try in Ruby**:
-   ```ruby
-   require 'ruby-progress'
-   RubyProgress::Ripple.progress("Testing...") { sleep 2 }
-   ```
+## Try It Out
 
-## Conclusion
+The easiest way to get started:
 
-Ruby-progress transforms boring CLI applications into engaging user experiences. Whether building deployment scripts, data processing tools, or utility commands, it provides the visual feedback users expect from modern command-line tools.
+{% iterm "gem install ruby-progress" %}
 
-The daemon mode alone makes it worth trying - no other progress library offers this level of flexibility for complex workflows.
+{% iterm "prg ripple 'Hello, World!'" %}
 
-**Links:**
-- [GitHub](https://github.com/ttscoff/ruby-progress)
-- [RubyGems](https://rubygems.org/gems/ruby-progress)
-- [Latest Release](https://github.com/ttscoff/ruby-progress/releases/latest)
+Or check out the [GitHub repository](https://github.com/ttscoff/ruby-progress)
+for full documentation, examples, and the complete API reference. The README
+includes detailed guides for each indicator type and advanced usage patterns.
 
-*Make your CLI tools feel alive with ruby-progress!*
+The gem is also available on
+[RubyGems](https://rubygems.org/gems/ruby-progress), and the latest release
+includes significant improvements to daemon mode handling and job control
+commands.