lx

lx

lx is a CLI context bundler for Large Language Models.

It recursively discovers files, respects ignore rules, detects binaries, and formats content into Markdown, XML, or HTML with built-in token estimation.

Unlike simple file concatenators, lx treats arguments as a stream. This allows you to apply state modifiers (like line limits or filters) to specific subsets of files within a single command.

Installation • Usage • Stream Processing • Configuration

Features

• Token Aware: Automatically calculates token estimates for every file and the total bundle.
• Smart Traversal: Respects .gitignore, .ignore, and .lxignore. Skips binary files by default.
• Stream Processing: Apply different rules (e.g., --tail 50) to different files in one pass.
• LLM Optimized: Outputs Markdown (GitHub/OpenAI), XML (Claude), or HTML (visual debugging).
• Clipboard Ready: Pipes output directly to the system clipboard on Linux (xclip/wl-copy), macOS, and Windows.
• Pipeline Friendly: Accepts file lists via stdin from tools like find, fd, or git.

Installation

Via Go install

go install github.com/rasros/lx/cmd/lx@latest

Via Curl (Pre-built binaries)

curl -fsSL https://raw.github.com/rasros/lx/main/install.sh | bash

Dependencies

Clipboard support (-c) requires:

• Linux (X11): xclip
• Linux (Wayland): wl-clipboard
• macOS / Windows: Native support included.

Usage

Basic Bundling

Walk the current directory, ignoring hidden/gitignored files, and copy to clipboard:

lx -c

Filter by Type

Find Python files, exclude tests:

lx -i "*.py" -e "*test*" src/

Output XML (Recommended for Claude)

Output entire directory as structured xml:

lx --xml .

Prompt Injection

Inject a custom text before the file context:

lx -p "Refactor the following code to use contexts:" main.go

Manually Sectioned Parts

Injects a custom header (also adjusts XML output):

lx -s "Code under test" src/database/users -s "Test fixtures" src/tests/fixtures

Using with fzf

Use fd to find files, lx to preview them, and lx again to bundle the selection:

# Requires: fd, fzf
fd -t f | fzf -m --preview 'lx -n 20 {}' | lx -c

Using with llm:

Pipe context directly into llm tool:

lx -p "Explain this project structure" src/ | llm

Using with git:

Bundle only the files changed in the current branch:

git diff --name-only main | lx -c

Stream Processing Model

Arguments are processed sequentially. Flags are not global; they are modifiers that apply to all subsequent actions until reset.

1. Modifiers: (-n, --tail, -i) Apply to subsequent files.
2. Actions: (file, dir/) Capture the current state.
3. Resets: (-N, -E) Clear active modifiers.

Example: Bundling a log file (last 50 lines) and the full source code in one command.

lx --tail 50 app.log -N src/main.go

Output Formats

Configuration

Defaults can be overridden via ~/.config/lx/config.yaml.

output_mode: "stdout"    # stdout, copy
output_format: "xml"     # markdown, xml, html
show_hidden: false
follow_symlinks: false
ignore: true             # Respect .gitignore

Comparison