### Install Slack Go Library

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/slack-go/slack/README.md

Command to install the slack-go/slack package into your Go project using go get.

```bash
go get -u github.com/slack-go/slack
```

--------------------------------

### Install regexp2 Package in Go

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/dlclark/regexp2/README.md

Provides instructions for installing the regexp2 Go package using the `go get` command. It also includes the command for installing the `code_gen` branch for beta features related to code generation.

```go
go get github.com/dlclark/regexp2

# For code generation (beta):
go get github.com/dlclark/regexp2@code_gen
```

--------------------------------

### Install Golang Color Library

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/fatih/color/README.md

Instructions to install the fatih/color library using the go get command. This is the primary step before using any of the library's features.

```go
go get github.com/fatih/color
```

--------------------------------

### Ralphex Bedrock Startup Output (Explicit Credentials)

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

This example shows the Ralphex startup output when using AWS Bedrock with explicitly provided credentials. It differs from the profile-based output by indicating the use of explicit credentials.

```text
using image: ghcr.io/umputun/ralphex-go:latest
claude provider: bedrock (keychain skipped)
  using explicit credentials
  passing: AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, CLAUDE_CODE_USE_BEDROCK
```

--------------------------------

### Install go-colorable package

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/mattn/go-colorable/README.md

Command to fetch and install the go-colorable library into your Go workspace.

```bash
go get github.com/mattn/go-colorable
```

--------------------------------

### Ralphex Installation via Go Install

Source: https://github.com/umputun/ralphex/blob/master/site/docs/index.html

Provides the command to install Ralphex using the Go programming language's install command.

```bash
go install github.com/umputun/ralphex/cmd/ralphex@latest
```

--------------------------------

### Ralphex Bedrock Startup Output (Profile Credentials)

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

This is an example of the startup output when Ralphex is configured to use AWS Bedrock with profile-based credentials. It indicates the image used, the Bedrock provider status, and the credentials being exported.

```text
using image: ghcr.io/umputun/ralphex-go:latest
claude provider: bedrock (keychain skipped)
  exporting credentials from profile: my-sso-profile
  passing: AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN, CLAUDE_CODE_USE_BEDROCK
```

--------------------------------

### Install ralphex from Source, Homebrew, or Releases

Source: https://github.com/umputun/ralphex/blob/master/llms.txt

This snippet shows how to install the ralphex tool. It covers installation from source using 'go install', via Homebrew, and from pre-compiled releases available on GitHub.

```bash
# from source
go install github.com/umputun/ralphex/cmd/ralphex@latest

# using homebrew
brew install umputun/apps/ralphex

# from releases: https://github.com/umputun/ralphex/releases
```

--------------------------------

### Install displaywidth package

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/clipperhouse/displaywidth/README.md

Command to install the displaywidth package using the Go toolchain.

```bash
go get github.com/clipperhouse/displaywidth
```

--------------------------------

### Install go-sse package

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/tmaxmax/go-sse/README.md

Command to install the go-sse library using the Go toolchain.

```shell
go get -u github.com/tmaxmax/go-sse
```

--------------------------------

### Start Ralphex Web Dashboard

Source: https://context7.com/umputun/ralphex/llms.txt

Launches a real-time web dashboard for monitoring plan execution. The dashboard supports SSE streaming, phase navigation, and text search. It can be started with a specified plan file and custom ports or by watching multiple directories.

```bash
# Start with web dashboard
ralphex --serve docs/plans/feature.md
# Dashboard available at http://localhost:8080

# Custom port
ralphex --serve --port 3000 docs/plans/feature.md

# Watch multiple directories for multi-session monitoring
ralphex --serve --watch ~/projects/frontend --watch ~/projects/backend
```

--------------------------------

### Implement a basic SSE client in Go

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/tmaxmax/go-sse/README.md

A complete example showing how to initialize a connection, subscribe to messages, and run the client to receive events from a server.

```go
package main

import (
    "fmt"
    "net/http"
    "os"
    "github.com/tmaxmax/go-sse"
)

func main() {
    r, _ := http.NewRequest(http.MethodGet, "http://localhost:8000", nil)
    conn := sse.NewConnection(r)

    conn.SubscribeMessages(func(ev sse.Event) {
        fmt.Printf("%s\n\n", ev.Data)
    })

    if err := conn.Connect(); err != nil {
        fmt.Fprintln(os.Stderr, err)
    }
}
```

--------------------------------

### Launch System Editor for Plan Editing

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/2026-02-15-interactive-plan-review.md

This pattern demonstrates how to create a temporary file, launch the user's preferred system editor ($VISUAL or $EDITOR), and read the modified content back into the application. It ensures proper cleanup using defer and handles the case where no editor is configured.

```go
tmpFile, err := os.CreateTemp("", "ralphex-plan-*.md")
if err != nil {
	return err
}
defer os.Remove(tmpFile.Name())

editor := os.Getenv("VISUAL")
if editor == "" {
	editor = os.Getenv("EDITOR")
}
if editor == "" {
	editor = "vi"
}

cmd := exec.CommandContext(ctx, editor, tmpFile.Name())
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err = cmd.Run()
```

--------------------------------

### Enable Session-Wide Bedrock Mode (Bash)

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

This example shows how to enable Bedrock mode for all Ralphex commands within a session by setting the `RALPHEX_CLAUDE_PROVIDER` environment variable. This avoids the need to specify the `--claude-provider bedrock` flag for each command.

```bash
export AWS_PROFILE=ralphex-bedrock
export AWS_REGION=us-east-1
export RALPHEX_CLAUDE_PROVIDER=bedrock

# All ralphex commands now use Bedrock
ralphex docs/plans/feature.md
ralphex --review
```

--------------------------------

### Initialize go-sse server

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/tmaxmax/go-sse/README.md

Demonstrates how to instantiate a new sse.Server instance. The server is framework-agnostic and implements the http.Handler interface.

```go
import "github.com/tmaxmax/go-sse"

s := &sse.Server{} // zero value ready to use!
```

--------------------------------

### Creating a Server-Sent Events Server in Go

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/tmaxmax/go-sse/README.md

Provides a complete example of setting up an SSE server in Go that publishes a "Hello world" message every second. It integrates with net/http for serving events and uses the go-sse library for message handling.

```go
package main

import (
    "log"
    "net/http"
    "time"

    "github.com/tmaxmax/go-sse"
)

func main() {
    s := &sse.Server{}

    go func() {
        m := &sse.Message{}
        m.AppendData("Hello world")

        for range time.Tick(time.Second) {
            _ = s.Publish(m)
        }
    }()

    if err := http.ListenAndServe(":8000", s); err != nil {
        log.Fatalln(err)
    }
}
```

--------------------------------

### Create a plan using the --plan flag

Source: https://github.com/umputun/ralphex/blob/master/README.md

This command demonstrates how to create a plan for ralphex using the `--plan` flag, followed by a descriptive string outlining the desired action. ralphex will then analyze the codebase and generate a plan file.

```bash
ralphex --plan "add health check endpoint"
```

--------------------------------

### Install termenv Library

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/muesli/termenv/README.md

Command to install the termenv Go library using the go get command. This adds the library to your project's dependencies.

```bash
go get github.com/muesli/termenv
```

--------------------------------

### Custom HTML Formatter Configuration

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/alecthomas/chroma/v2/README.md

Demonstrates how to initialize a custom HTML formatter and write the associated CSS to a writer.

```go
formatter := html.New(html.WithClasses(true))
err := formatter.WriteCSS(w, style)
```

--------------------------------

### Interactive Plan Creation with Ralphex CLI

Source: https://github.com/umputun/ralphex/blob/master/site/docs/index.html

Demonstrates how to use the Ralphex CLI to create a plan for adding API caching. It shows the interactive prompts for selecting a cache backend and the final output of the generated plan file.

```bash
ralphex --plan "add caching for API"

[10:30:05] analyzing codebase structure...
[10:30:12] found store layer in pkg/store/
QUESTION: Which cache backend?
› Redis
  In-memory
  File-based
[10:30:45] ANSWER: Redis
[10:32:05] plan written → docs/plans/add-api-caching.md
```

--------------------------------

### Create Toy Project for Testing (Shell Script)

Source: https://github.com/umputun/ralphex/blob/master/CLAUDE.md

This shell script prepares a toy project environment for end-to-end testing. It creates a directory `/tmp/ralphex-test` containing a buggy Go file and a plan file, which is used to verify the ralphex tool's functionality in fixing issues.

```bash
./scripts/internal/prep-toy-test.sh
```

--------------------------------

### Install Playwright Go Package

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/playwright-community/playwright-go/README.md

Installs the Playwright Go library using the go get command. This is the standard way to add Go packages to your project.

```shell
go get -u github.com/playwright-community/playwright-go
```

--------------------------------

### Install Repeater Package

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/go-pkgz/repeater/README.md

Installs or updates the 'repeater' Go package to the latest version using the go get command. This is the standard way to manage dependencies in Go projects.

```bash
go get -u github.com/go-pkgz/repeater
```

--------------------------------

### Glamour Renderer Configuration (Go)

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/2026-01-29-plan-draft-preview.md

Demonstrates the configuration of the Glamour renderer for displaying text with styling. It includes options for auto-detecting dark/light themes and setting a fixed word wrap width. The `--no-color` flag is used to bypass color rendering.

```go
import "github.com/charmbracelet/glamour"

// ...

renderer, err := glamour.NewTermRenderer(
	glamour.WithAutoStyle(),
	glamour.WithWordWrap(80),
)
// ...
// Bypass glamour when --no-color flag is set
```

--------------------------------

### Progress File Completion Footer Format (Example)

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/20260218-progress-fresh-start.md

This example shows the format of the completion footer written by the `Close()` function in the progress logger. It includes the timestamp of completion and the elapsed time.

```Text
Completed: 2006-01-02 15:04:05 (elapsed)
```

--------------------------------

### Configure Joe with ValidReplayer

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/tmaxmax/go-sse/README.md

Demonstrates initializing a ValidReplayer with a TTL and attaching it to the Joe provider.

```go
r, err := sse.NewValidReplayer(time.Minute * 5, false)
if err != nil {
	// TTL was 0 or negative.
}

joe = &sse.Joe{Replayer: r}
```

--------------------------------

### Custom External Review Script Example

Source: https://context7.com/umputun/ralphex/llms.txt

Provides an example bash script (`my-review.sh`) to integrate a custom AI tool for external review. This script calls the OpenRouter API to get code review feedback based on a provided prompt file.

```bash
#!/bin/bash
# ~/.config/ralphex/scripts/my-review.sh
prompt_file="$1"
prompt=$(cat "$prompt_file")

# Call OpenRouter API
curl -s https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"model\": \"anthropic/claude-3.5-sonnet\",
    \"messages\": [{\"role\": \"user\", \"content\": $(echo "$prompt" | jq -Rs .)}]
  }" | jq -r '.choices[0].message.content'
```

--------------------------------

### Simple terminfo Example in Go

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/xo/terminfo/README.md

Demonstrates basic usage of the terminfo package in Go. It initializes the terminal, sets a title, displays colored blocks, and handles interrupt signals for graceful exit. Dependencies include standard Go libraries and the terminfo package.

```go
// _examples/simple/main.go
package main

import (
	"bytes"
	"fmt"
	"log"
	"os"
	"os/signal"
	"strings"
	"sync"
	"syscall"

	"github.com/xo/terminfo"
)

func main() {
	//r := rand.New(nil)

	// load terminfo

ti, err := terminfo.LoadFromEnv()
	if err != nil {
		log.Fatal(err)
	}

	// cleanup
	defer func() {
		err := recover()
		termreset(ti)
		if err != nil {
			log.Fatal(err)
		}
	}()

	terminit(ti)
	termtitle(ti, "simple example!")
	termputs(ti, 3, 3, "Ctrl-C to exit")
	maxColors := termcolors(ti)
	if maxColors > 256 {
		maxColors = 256
	}
	for i := 0; i < maxColors; i++ {
		termputs(ti, 5+i/16, 5+i%16, ti.Colorf(i, 0, "█"))
	}

	// wait for signal
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	<-sigs
}

// terminit initializes the special CA mode on the terminal, and makes the
// cursor invisible.
func terminit(ti *terminfo.Terminfo) {
	buf := new(bytes.Buffer)
	// set the cursor invisible

ti.Fprintf(buf, terminfo.CursorInvisible)
	// enter special mode

ti.Fprintf(buf, terminfo.EnterCaMode)
	// clear the screen

ti.Fprintf(buf, terminfo.ClearScreen)
	os.Stdout.Write(buf.Bytes())
}

// termreset is the inverse of terminit.
func termreset(ti *terminfo.Terminfo) {
	buf := new(bytes.Buffer)

ti.Fprintf(buf, terminfo.ExitCaMode)

ti.Fprintf(buf, terminfo.CursorNormal)
	os.Stdout.Write(buf.Bytes())
}

// termputs puts a string at row, col, interpolating v.
func termputs(ti *terminfo.Terminfo, row, col int, s string, v ...interface{}) {
	buf := new(bytes.Buffer)

ti.Fprintf(buf, terminfo.CursorAddress, row, col)
	fmt.Fprintf(buf, s, v...)
	os.Stdout.Write(buf.Bytes())
}

// sl is the status line terminfo.
var sl *terminfo.Terminfo

// termtitle sets the window title.
func termtitle(ti *terminfo.Terminfo, s string) {
	var once sync.Once
	once.Do(func() {
		if ti.Has(terminfo.HasStatusLine) {
			return
		}
		// load the sl xterm if terminal is an xterm or has COLORTERM
		if strings.Contains(strings.ToLower(os.Getenv("TERM")), "xterm") || os.Getenv("COLORTERM") == "truecolor" {
			sl, _ = terminfo.Load("xterm+sl")
		}
	})
	if sl != nil {
		ti = sl
	}
	if !ti.Has(terminfo.HasStatusLine) {
		return
	}
	buf := new(bytes.Buffer)

ti.Fprintf(buf, terminfo.ToStatusLine)
	fmt.Fprint(buf, s)

ti.Fprintf(buf, terminfo.FromStatusLine)
	os.Stdout.Write(buf.Bytes())
}

// termcolors returns the maximum colors available for the terminal.
func termcolors(ti *terminfo.Terminfo) int {
	if colors := ti.Num(terminfo.MaxColors); colors > 0 {
		return colors
	}
	return int(terminfo.ColorLevelBasic)
}

```

--------------------------------

### Define Document and Paragraph Styles

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/charmbracelet/glamour/styles/README.md

Examples of JSON configuration for the document body and paragraph elements, defining indentation, margins, and color schemes.

```json
"document": {
    "indent": 2,
    "background_color": "234",
    "block_prefix": "\n",
    "block_suffix": "\n"
}

"paragraph": {
    "margin": 4,
    "color": "15",
    "background_color": "235"
}
```

--------------------------------

### Define Block Quote, List, and Code Block Styles

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/charmbracelet/glamour/styles/README.md

Configuration examples for specialized block elements including block_quote, list, and code_block with syntax highlighting theme settings.

```json
"block_quote": {
    "color": "200",
    "indent": 1,
    "indent_token": "=> "
}

"list": {
    "color": "15",
    "background_color": "52",
    "level_indent": 4
}

"code_block": {
    "color": "200",
    "theme": "solarized-dark"
}
```

--------------------------------

### Re-authenticate SSO Session (Bash)

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

This command is used to re-authenticate your AWS SSO session when it has expired, which can cause 'ExpiredToken' errors. It's a common troubleshooting step for Bedrock authentication issues.

```bash
aws sso login --profile=ralphex-bedrock
```

--------------------------------

### Cross-Platform Build Command

Source: https://github.com/umputun/ralphex/blob/master/CLAUDE.md

Demonstrates how to cross-compile the Ralphex project for Windows environments using Go build tags and environment variables.

```bash
GOOS=windows GOARCH=amd64 go build ./...
```

--------------------------------

### Configure and Run Ralphex with AWS

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

Commands to configure AWS profiles and execute Ralphex using different authentication strategies including SSO, IAM user keys, and explicit environment variables.

```bash
aws configure sso --profile ralphex-bedrock
aws sso login --profile=ralphex-bedrock
export AWS_PROFILE=ralphex-bedrock
export AWS_REGION=us-east-1
ralphex --claude-provider bedrock docs/plans/feature.md
```

```bash
aws configure --profile ralphex-bedrock
export AWS_PROFILE=ralphex-bedrock
export AWS_REGION=us-east-1
ralphex --claude-provider bedrock docs/plans/feature.md
```

```bash
export AWS_REGION=us-east-1
export AWS_ACCESS_KEY_ID=AKIA...
export AWS_SECRET_ACCESS_KEY=...
ralphex --claude-provider bedrock docs/plans/feature.md
```

--------------------------------

### Progress File Additions (Text)

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/2026-01-29-plan-draft-preview.md

Illustrates the format for adding draft review and feedback information to the progress file. Includes timestamps for logging.

```text
[HH:MM:SS] DRAFT REVIEW: accept

```

```text
[HH:MM:SS] DRAFT REVIEW: revise
[HH:MM:SS] FEEDBACK: user's revision feedback here
```

--------------------------------

### Pass Extra Environment Variables to Ralphex (Bash)

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

This snippet illustrates how to pass additional environment variables to Ralphex when running with the Bedrock provider. The `-E` flag is used to forward variables like `CLAUDE_CODE_MAX_OUTPUT_TOKENS` to the Ralphex process.

```bash
export AWS_PROFILE=ralphex-bedrock
export AWS_REGION=us-east-1
export CLAUDE_CODE_MAX_OUTPUT_TOKENS=32000

# Pass extra env vars to container
ralphex --claude-provider bedrock -E CLAUDE_CODE_MAX_OUTPUT_TOKENS docs/plans/feature.md
```

--------------------------------

### Define AWS IAM Policies for Bedrock

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

JSON policies defining the minimum required permissions to invoke Claude models on AWS Bedrock. Includes both a broad policy for all Claude models and a restrictive policy for specific models and regions.

```json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "BedrockInvokeFoundationModels",
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Resource": [
                "arn:aws:bedrock:*::foundation-model/anthropic.claude-*"
            ]
        },
        {
            "Sid": "BedrockInvokeInferenceProfiles",
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Resource": [
                "arn:aws:bedrock:*:*:inference-profile/*anthropic.claude*"
            ]
        }
    ]
}
```

```json
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "BedrockInvokeClaudeFoundationModels",
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Resource": [
                "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-20250514-v1:0",
                "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-haiku-4-20250514-v1:0"
            ]
        },
        {
            "Sid": "BedrockInvokeClaudeInferenceProfiles",
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:InvokeModelWithResponseStream"
            ],
            "Resource": [
                "arn:aws:bedrock:us-east-1:*:inference-profile/us.anthropic.claude-sonnet-4-20250514-v1:0",
                "arn:aws:bedrock:us-east-1:*:inference-profile/us.anthropic.claude-haiku-4-20250514-v1:0"
            ]
        }
    ]
}
```

--------------------------------

### Set Up Ralphex with Bedrock (Bash)

Source: https://github.com/umputun/ralphex/blob/master/docs/bedrock-setup.md

This snippet demonstrates how to set up the required environment variables for Ralphex to use AWS Bedrock with an SSO profile. It includes setting the AWS profile and region, logging in via SSO, and running Ralphex with the Bedrock provider flag.

```bash
# Set required environment
export AWS_PROFILE=ralphex-bedrock
export AWS_REGION=us-east-1

# Login if needed
aws sso login --profile=ralphex-bedrock

# Run with Bedrock provider
ralphex --claude-provider bedrock docs/plans/feature.md
```

--------------------------------

### Draft Review Actions (Text)

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/2026-01-29-plan-draft-preview.md

Defines the possible actions for draft review: 'accept' to proceed with writing the plan file, 'revise' to re-run Claude with feedback and emit a new PLAN_DRAFT, and 'reject' to exit plan creation with an error.

```text
accept - proceed to write plan file
revise - re-run Claude with feedback, emit new PLAN_DRAFT
reject - exit plan creation with error
```

--------------------------------

### Ralphex Service Initialization with Custom VCS Command

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/2026-02-25-vcs-command-config.md

Demonstrates how to initialize the Ralphex service to use a custom script, such as `hg2git.sh`, for all version control operations. This is achieved by setting the `vcs_command` in the configuration.

```go
import (
	"log"
	"path/to/ralphex/git"
)

// Assuming log is initialized elsewhere
var logger *log.Logger

// Initialize Ralphex service with a custom VCS command
service := git.NewService(".", logger, "/path/to/scripts/hg2git.sh")

```

--------------------------------

### Install Playwright Programmatically

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/playwright-community/playwright-go/README.md

Installs the Playwright driver and browsers directly within your Go code. This method requires manual installation of system dependencies if they are missing.

```go
err := playwright.Install()

```

--------------------------------

### Initiating an SSE Client Connection in Go

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/tmaxmax/go-sse/README.md

Shows how to establish a connection to an SSE stream using the default go-sse client. It involves creating an http.Request and then using the client's NewConnection method or the utility function sse.NewConnection.

```go
import "github.com/tmaxmax/go-sse"

conn := sse.DefaultClient.NewConnection(req)
// you can also do sse.NewConnection(req)
// it is an utility function that calls the
// NewConnection method on the default client
```

--------------------------------

### Update Make Plan Prompt (Text)

Source: https://github.com/umputun/ralphex/blob/master/docs/plans/completed/2026-01-29-plan-draft-preview.md

Modifies the `make_plan.txt` prompt to instruct Claude on handling plan drafts. It includes steps for presenting the draft, waiting for user feedback (accept, revise, reject), and processing revision history. This ensures Claude generates plans compatible with the new feedback loop.

```text
...
Step 3.5: Present Draft for Review
Instruct Claude to emit the generated plan within `<<<RALPHEX:PLAN_DRAFT>>>` and `<<<RALPHEX:END>>>` markers. Claude must STOP execution after emitting the draft and wait for user feedback.

Handle user feedback:
- If user accepts: Proceed to Step 4.
- If user revises: Incorporate the feedback provided by the user. Add the feedback to the progress file for context. Re-emit the plan draft using `<<<RALPHEX:PLAN_DRAFT>>>...<<<RALPHEX:END>>>` with the updated plan.
- If user rejects: Emit `TASK_FAILED` signal and terminate.

Step 4: Finalize Plan
This step should only execute after the user has accepted the plan draft.
...
Ensure the prompt continues to reference the progress file for revision history when generating updated plans.
...
```

--------------------------------

### Install Playwright Driver and Browsers

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/playwright-community/playwright-go/README.md

Installs the Playwright driver and necessary browser binaries. The --with-deps flag attempts to install OS-level dependencies. Replace v0.xxxx.x with your project's playwright-go version.

```shell
go run github.com/playwright-community/playwright-go/cmd/playwright@v0.xxxx.x install --with-deps
```

```shell
go install github.com/playwright-community/playwright-go/cmd/playwright@v0.xxxx.x
playwright install --with-deps
```

--------------------------------

### Ralphex Installation via Homebrew (macOS)

Source: https://github.com/umputun/ralphex/blob/master/site/docs/index.html

Provides the command to install Ralphex on macOS using the Homebrew package manager.

```bash
brew install umputun/apps/ralphex
```

--------------------------------

### Configure Formatter and Style

Source: https://github.com/umputun/ralphex/blob/master/vendor/github.com/alecthomas/chroma/v2/README.md

Retrieves a style and formatter from the registry, falling back to defaults if the requested items are not found.

```go
style := styles.Get("swapoff")
if style == nil {
  style = styles.Fallback
}
formatter := formatters.Get("html")
if formatter == nil {
  formatter = formatters.Fallback
}
```