rtk

RTK intercepts CLI tool outputs and applies specialized parsing logic through a pluggable OutputParser framework that understands command semantics (git, npm, python, etc.). The system uses language-aware filtering rules to strip verbose/redundant output while preserving critical information, achieving 60-90% token reduction. Filtering decisions are based on command type, verbosity settings, and domain-specific heuristics encoded in the parser modules.

RTK installs transparent shell hooks (bash, zsh, fish, PowerShell) that automatically rewrite commands at execution time. When an LLM agent invokes a command like 'git status', the hook intercepts it and rewrites it to 'rtk git status' before execution, ensuring the agent receives optimized output without code changes. The hook system supports multiple installation modes and integrates with agent-specific settings files (Claude Code settings.json, OpenCode config).

RTK provides specialized optimization for git commands (status, diff, log, show, etc.) that strips verbose metadata, removes untracked file listings, filters diff context, and abbreviates commit hashes. The git module understands git output semantics and preserves critical information (file changes, commit messages) while removing noise. Optimization is context-aware — different filtering rules apply to git status vs git log vs git diff.

RTK provides specialized optimization for JavaScript/TypeScript package managers (npm, yarn, pnpm) that filters dependency trees, removes verbose install logs, abbreviates package versions, and removes redundant metadata. The module detects the active package manager and applies appropriate filtering. Optimization preserves critical information (package names, versions, errors) while removing noise from dependency resolution logs.

RTK provides specialized optimization for Python package managers (pip, poetry, uv) that filters dependency resolution logs, removes verbose build output, abbreviates package versions, and removes redundant metadata. The module detects the active Python package manager and applies appropriate filtering. Optimization preserves critical information (package names, versions, errors) while removing noise from installation and dependency resolution logs.

RTK provides specialized optimization for Docker commands (ps, logs, inspect, build, etc.) that filters verbose output, removes redundant metadata, abbreviates container IDs and image digests, and removes build step details. The module understands Docker output semantics and preserves critical information (container status, error messages, image names) while removing noise.

RTK provides specialized optimization for test runners (Jest, pytest, Go test, Cargo test, etc.) that filters passing test output, removes verbose test logs, abbreviates stack traces, and preserves critical failure information. The module understands test output semantics and applies intelligent filtering that removes noise while ensuring LLM agents can still detect and debug test failures.

RTK maintains a persistent SQLite database that tracks token savings across all executed commands, storing metrics like raw output size, filtered output size, estimated token reduction, and command type. The system provides analytics commands (gain, discover, learn) that query this database to show cumulative savings, identify high-impact commands, and recommend optimization strategies. Token tracking is automatic and requires no configuration.

RTK transparently preserves exit codes from wrapped commands, ensuring that LLM agents can detect command failures and errors correctly. The system implements fallback mechanisms that pass through unoptimized output if parsing fails, maintaining command reliability. Error handling is designed to be invisible — if RTK encounters an unsupported command or parsing error, it degrades gracefully to unfiltered output rather than failing the command.

RTK provides specialized command modules for 40+ development tools organized by ecosystem (JavaScript/TypeScript, Python, Go, Rust, Git, Docker, etc.). Each module contains domain-specific parsing logic and filtering rules tailored to that tool's output format. Modules are loaded dynamically based on the command being executed, enabling efficient coverage of diverse development workflows without monolithic code.

RTK includes a TOML-based filter engine that allows users to define custom output filtering rules without modifying source code. The engine supports pattern matching, field selection, and conditional filtering through declarative TOML configuration. Users can create custom filter profiles for specific workflows or tools, enabling fine-grained control over what information is preserved in optimized output.

RTK automatically detects the active package manager (npm, yarn, pnpm, pip, cargo, etc.) in a project and applies optimized filtering for that manager's commands. Detection uses heuristics like lock file presence (package-lock.json, yarn.lock, Cargo.lock) and project configuration. This enables context-aware optimization without explicit configuration.

RTK is distributed as a single, self-contained Rust binary with zero external dependencies, compiled for macOS (Intel/ARM), Linux (x86_64/ARM), and Windows. The binary includes all parsing logic, filtering rules, and analytics code compiled into a single executable, eliminating dependency management overhead. Installation is as simple as downloading the binary and adding it to PATH.

RTK provides native integration with Claude Code and OpenCode agents through settings file hooks and configuration management. The system automatically detects and integrates with agent-specific configuration files (Claude Code settings.json, OpenCode config), enabling one-command installation that modifies agent settings to use RTK without manual configuration. Integration is transparent to the agent — it receives optimized output without code changes.

RTK implements a command dispatch system that routes incoming commands to appropriate handler modules based on command name and context. The system uses dynamic module loading to load only necessary parsing logic, minimizing memory overhead and startup latency. Dispatch logic handles command aliases, subcommands, and fallback mechanisms for unsupported commands.