rtk-ai/rtk

RTK is a CLI tool designed to reduce token consumption and improve context efficiency for AI coding assistants by intercepting and rewriting shell commands. It provides a modular system of ecosystem-specific filters for languages like Rust, Python, and JavaScript, alongside a native hook engine that integrates with various LLM agents to optimize command execution. The system also includes analytics for tracking savings and configuration options to control the level of context injected into AI workflows.

This change introduces a new Go command module (\src/cmds/go\) that enables structured filtering of Go toolchain output. It supports \go test\, \go build\, and \go vet\ by injecting the \-json\ flag to parse NDJSON streaming events, ensuring accurate reporting of test results and build errors. Additionally, it adds support for \golangci-lint\ via \go tool golangci-lint\, including version detection (handling both v1 and v2) and structured JSON output parsing for lint issues.

src/cmds/go · high confidence

New command modules have been added to the Ruby integration to filter and summarize test and lint output. The Rake module parses Minitest output to show only failures, automatically switching between \rake test\ and \rails test\ based on arguments. The RSpec module injects JSON formatting to provide structured failure summaries, with a text-based fallback. The RuboCop module similarly uses JSON output to group and rank offenses by severity, limiting the displayed results to keep output concise. All three modules leverage \ruby\_exec\ to automatically detect and use \bundle exec\ when a Gemfile is present.

src/cmds/ruby · high confidence

Users can now run SBT tasks directly through the CLI. This change introduces a new \scala\ command module that delegates to \sbt\, supporting standard tasks like \test\, \compile\, and \run\, as well as scoped task notation (e.g., \Test/test\). The implementation includes output filtering to parse and display summaries for ScalaTest and munit, handles integration test scopes, and routes execution through a shared runner for consistent tracking and error handling.

src/cmds/scala · high confidence

The \scripts/benchmark-sessions/lib/runner.py\ module has been added to automate the execution of benchmark sessions. This script manages the lifecycle of virtual machines (creating and destroying pools), sets up codebases, configures RTK, runs Claude sessions, and optionally executes terminal-bench precision tests. It handles temporary file cleanup and writes a manifest of the results to the specified output directory.

scripts/benchmark-sessions · high confidence

A new pre-commit hook has been added to automatically format Rust code using cargo fmt and run clippy checks before every commit. This ensures that code is consistently formatted and free of compilation errors (though warnings are allowed) before being committed to the repository.

.claude/hooks/bash · high confidence

This change introduces a dedicated PHP command module that integrates and filters output for common PHP development tools: PHP syntax checks, Laravel Artisan, PHPUnit, Pest, ParaTest, PHPStan, EasyCodingStandard (ECS), and Pint. Each tool now benefits from standardized output processing—such as stripping ANSI codes, suppressing verbose progress bars, and presenting compact, actionable summaries (e.g., grouping PHPStan errors by file, limiting Pint changes to the top 15 files, or showing only failure diffs for PHPUnit/Pest). The module also handles local tool resolution via Composer's \vendor/bin\ directory, ensuring consistent behavior across different project setups.

src/cmds/php · high confidence

Adds the OpenClaw plugin for transparent exec rewriting, which intercepts shell commands via a \before\_tool\_call\ hook and delegates them to \rtk rewrite\. This replaces original commands with optimized RTK equivalents, cutting up to 90% of bash output that reaches the LLM context. The plugin manages its own approval flow—relaxing the default 'ask' gate for commands that match no specific rule while preserving explicit user-defined \ask\ rules and \deny\ blocks—ensuring OpenClaw retains ownership of execution policy without redundant prompts from RTK.

openclaw · high confidence

Added two new shell hooks in .claude/hooks to integrate with Claude Code's PreToolUse:Bash event. The rtk-rewrite.sh hook automatically rewrites supported shell commands to their RTK equivalents using the 'rtk rewrite' binary, handling permission decisions (auto-allow, deny, or ask) and providing optional audit logging. The rtk-suggest.sh hook detects common commands (git, cargo, pnpm, docker, etc.) and suggests RTK alternatives via system messages to highlight potential token savings, without modifying execution.

.claude/hooks · high confidence

Added new modules in \src/cmds/rust\ to handle Rust-specific tooling. \cargo\_cmd.rs\ implements filtering and summary logic for \cargo build\, \test\, \clippy\, \check\, \install\, and \nextest\, including support for JSON diagnostics and specific output formatting (e.g., preserving \--\ for test flags). \runner.rs\ provides a generic execution layer that runs commands via argument vectors (preserving Clap-parsed boundaries) or an explicit shell script, serving as a fallback for commands without dedicated filters and reusing core error/test runner logic.

src/cmds/rust · high confidence

Users can now control how much RTK context is injected into AI coding assistants via a new \\[awareness\]\ configuration table in \\~/.config/rtk/config.toml\. The \level\ setting accepts \default\, \high\, or \full\, allowing operators to choose between a minimal output contract, a version that explains RTK's existence and meta-commands, or a version that instructs agents to prefix every command with \rtk\. This replaces the previous static, single-level awareness text with a tiered approach that reduces token waste for hook-based agents while providing necessary context for rules-only agents.

(repo-wide) · high confidence

This change establishes the \src/core\ module as the central infrastructure layer for the application, providing domain-agnostic building blocks consumed by all other components. It introduces a shared argument tokenizer (\arg\_tokenizer.rs\) that correctly handles complex CLI argument patterns (flags, values, positionals, and \--\ boundaries) across different tool dialects, replacing ad-hoc parsing. The module also includes a robust configuration system (\config.rs\) that manages user settings for tracking, display, filters, telemetry, and hooks, including support for legacy configuration migration. Additionally, it provides a content-addressed recall store (\retriever.rs\) for output recovery, a source code filter engine (\filter.rs\), and various utilities for display formatting, command execution, and telemetry.

src/core · high confidence

The new \src/discover\ module provides two capabilities: it rewrites LLM agent commands (e.g., converting \git status\ to \rtk git status\) via a lexer-aware pipeline that handles shell quoting, redirects, and compound commands, and it analyzes past Claude Code JSONL session files to identify commands that could have been rewritten but were not. This module introduces a shared lexer toolkit for tokenization and shell-splitting, a registry of 60+ rewrite rules with pipeline safety gates, and a reporting system that estimates token savings and adoption rates while distinguishing between measured hook-decision logs and heuristic estimates.

src/discover · high confidence

The \src/hooks\ module has been rewritten to replace legacy bash scripts with a native Rust hook system. This change introduces a centralized decision engine (\decision.rs\) that determines whether commands should be rewritten, allowed, or denied based on a strict permission precedence model (Deny \> Ask \> Allow \> Default). The new system supports installation and lifecycle management for a wide range of AI coding agents, including Claude Code, Copilot (VS Code and CLI), Cursor, Gemini, Codex, Trae, Factory Droid, Mistral Vibe, OpenCode, Pi, Oh My Pi, and Hermes. It features SHA-256 integrity verification to prevent tampering, native JSON protocol handling for each agent, and a new \rtk hook audit\ command for tracking rewrite activity. The permission model now enforces that all segments of compound commands must match allow rules to prevent bypasses, and defaults to 'ask' when no rules match, ensuring least-privilege security by default.

src/hooks · high confidence

A new parser module has been added to provide a unified, three-tier system for processing tool outputs: Tier 1 performs complete JSON parsing, Tier 2 falls back to regex-based partial parsing with warnings, and Tier 3 returns truncated raw output if parsing fails entirely. This infrastructure introduces canonical types for test results, lint results, dependency states, and build outputs, along with a token-efficient formatter that supports compact, verbose, and ultra-compressed display modes. Users benefit from more reliable tool integration that degrades gracefully rather than failing silently, with clear degradation markers visible in verbose mode.

src/parser · high confidence

A new \rtk learn\ command has been added to analyze Claude Code session history and identify recurring CLI errors, such as unknown flags, wrong paths, or missing arguments. The tool scans session logs to find patterns where a command fails and is subsequently corrected, classifying the error type and calculating a confidence score. Users can view these findings via a console report or JSON output, and optionally auto-generate a \.claude/rules/cli-corrections.md\ file to help prevent these mistakes in future sessions.

src/learn · high confidence

Added a new \src/cmds/dotnet\ module that provides structured parsing and filtering for .NET CLI output. The module includes \binlog.rs\ to parse MSBuild binary logs for build and test summaries, \dotnet\_trx.rs\ to parse Visual Studio TRX test result files, and \dotnet\_format\_report.rs\ to parse JSON format reports. The main \dotnet\_cmd.rs\ orchestrates these parsers for \build\, \test\, \restore\, and \format\ subcommands, enhancing output readability and reliability.

src/cmds/dotnet · high confidence

This change introduces a suite of new shell scripts to support continuous integration, local development, and quality assurance. The \scripts/benchmark.sh\ harness compares RTK command performance against standard Unix tools, while \scripts/test-all.sh\ provides a comprehensive smoke test suite for core commands. Additional scripts include \scripts/check-installation.sh\ for verifying the RTK environment, \scripts/check-test-presence.sh\ to enforce unit test coverage on new command modules, and \scripts/test-install.sh\ to validate security fixes against path traversal vulnerabilities. The suite also adds specialized tests for Ruby (\test-ruby.sh\), tracking validation (\test-tracking.sh\), and documentation consistency (\validate-docs.sh\), alongside utility scripts for local installation (\install-local.sh\) and economic impact analysis (\rtk-economics.sh\).

scripts · high confidence

This location introduces a new \src/cmds/git\ module that provides token-optimized wrappers for Git, GitHub CLI (gh), GitLab CLI (glab), and Graphite (gt). The \git\_cmd\ module filters standard Git commands (log, status, diff, show, stash, etc.) to show only essential information, while \gh\_cmd\ and \glab\_cmd\ compress CLI outputs by extracting key fields from JSON responses and filtering markdown noise. The \diff\_cmd\ module provides an ultra-condensed diff view showing only changed lines. These modules work together to reduce output verbosity across version control operations.

src/cmds/git · high confidence

Added streaming and buffered line filters for JVM build tools to reduce output noise. The Maven filter (\mvn\_cmd.rs\) replaces the previous TOML-based filter with a Rust state machine that collapses passing Surefire test blocks, deduplicates compile errors, handles Maven Daemon (\mvnd\) parallel reactor interleaving, and caps failure summaries. The Gradle filter (\gradlew\_cmd.rs\) provides a streaming filter for \./gradlew\ and \gradle\ commands, filtering task progress and build noise while preserving errors and actionable output.

src/cmds/jvm · high confidence

Added a new \src/cmds/js\ module providing structured, filtered execution for the JavaScript/TypeScript ecosystem. This includes dedicated commands for Bun (\bun\_cmd\), Deno (\deno\_cmd\), npm/npx (\npm\_cmd\), pnpm (\pnpm\_cmd\), TypeScript (\tsc\_cmd\), Vitest (\vitest\_cmd\), ESLint/Biome (\lint\_cmd\), Prettier (\prettier\_cmd\), Next.js (\next\_cmd\), Playwright (\playwright\_cmd\), and Prisma (\prisma\_cmd\). Each module implements specific output filtering (e.g., stripping ANSI codes, hiding progress bars, grouping diagnostics) and routing through the core runner to ensure consistent, concise user-facing output.

src/cmds/js · high confidence

The \src/cmds/python\ module introduces a suite of commands that wrap and filter standard Python tooling to provide compact, structured output. \mypy\_cmd\ parses and groups type errors by file and code. \pip\_cmd\ auto-detects \uv\ as a pip alternative, filters \list\ and \outdated\ JSON into grouped summaries, and passthroughs write operations. \pytest\_cmd\ uses a state-machine parser to show only failures and a summary, handling both standard and quiet modes. \ruff\_cmd\ injects JSON for check mode to group issues by rule and file, while respecting user-supplied output formats. \sqlfluff\_cmd\ injects JSON for lint mode, grouping violations by file and rule with deterministic ordering. \uv\_cmd\ preserves \uv run\ environment semantics, passing through successful program output and extracting diagnostics on failure. A README documents these specifics and cross-command integrations.

src/cmds/python · high confidence

The \src/analytics\ module now provides read-only dashboards that query the tracking database to report on bash output reduction, economic spending versus savings, and user adoption metrics. This includes the \rtk gain\ command for a token savings dashboard, \rtk cc-economics\ for dual-metric cost analysis (combining \ccusage\ data with RTK tracking), and \rtk session\ for adoption analysis of RTK-routed versus raw commands. These tools parse recorded data to surface savings percentages, spending estimates, and session-level reports without modifying the underlying tracking database.

src/analytics · high confidence

Added a new \src/cmds/cloud\ module providing specialized output filters for AWS, container runtimes, and web tools. The AWS module (\aws\_cmd.rs\) covers 25 subcommands (including STS, S3, EC2, ECS, RDS, CloudFormation, CloudWatch Logs, Lambda, IAM, DynamoDB, EKS, SQS, and Secrets Manager), forcing JSON output for structured parsing and using \force\_tee\_hint()\ for truncation recovery. The container module (\container.rs\) handles Docker (ps, images, logs) and Kubernetes/OpenShift (pods, services, logs) with compact summaries and passthrough for unknown subcommands. Additional modules include \curl\_cmd.rs\ (truncates long responses, saves full output for recovery, and passes through binary downloads to prevent UTF-8 corruption), \wget\_cmd.rs\ (strips progress bars, shows result summary), and \psql\_cmd.rs\ (filters PostgreSQL table and expanded display formats into compact output).

src/cmds/cloud · high confidence

The benchmark scripts now include a comprehensive integration test suite that provisions an Ubuntu 24.04 virtual machine via Multipass. This environment is pre-configured with a wide range of developer tools (Rust, Node.js, Go, Python, .NET, Docker, Kubernetes, etc.) and includes mock implementations for heavy external CLI tools. The suite executes a multi-phase test plan covering cargo quality checks, core RTK commands (git, files, search, data, runners, network, GitHub, cargo, python, go, typescript, linters, docker, k8s, dotnet), and TOML filtering, while also measuring token savings and generating detailed pass/fail reports.

scripts/benchmark · high confidence

This change introduces a suite of new commands under the system utilities module: \ast-grep\ filters AST-grep plain-mode output by grouping matches and capping results; \ctest\ compacts CTest output while preserving failing-test details and validating summaries; \deps\ summarizes project dependencies from lock files (Cargo.toml, package.json, requirements.txt, pyproject.toml, go.mod); \env\ filters and categorizes environment variables; \find\ filters file search results by grouping and supports both native and RTK syntax; \format\ auto-detects and runs code formatters (Prettier, Ruff, Black, Biome) showing only changed files; \json\ inspects JSON structure with optional schema-only mode and BOM handling; \local\_llm\ provides heuristic-based code summarization without external models; and \log\ captures and summarizes command output. These commands provide token-efficient, filtered views of common development tasks.

src/cmds/system · high confidence

The \src/cmds\ module now provides a centralized system for executing external CLI tools and filtering their output to reduce token consumption. It organizes command-specific filters by ecosystem (e.g., git, rust, js, python, go, dotnet, cloud, system, ruby, php, scala) and uses a shared runner in \core/runner.rs\ to handle execution, streaming, and tracking. Modules can choose between capture-only, buffered, streaming, or passthrough filter modes depending on the command's output characteristics, ensuring efficient processing while preserving exit codes and tracking token savings.

src/cmds · high confidence

The \src/hooks/init\ module has been reorganized from a single \init.rs\ file into dedicated submodules for each supported agent (agents\_md, claude, codex, copilot, cursor, droid, gemini, hermes, and instructions\_agents). This change improves code maintainability by isolating agent-specific installation and uninstallation logic, while preserving the existing user-facing behavior for configuring RTK across all supported environments.

src/hooks/init · high confidence

The CLI has been completely restructured from a monolithic design into a modular command system. The legacy \filter.rs\, \local\_llm.rs\, \ls.rs\, and \read.rs\ modules have been removed and replaced by a new \cmds\ registry that handles routing for a wide range of tools (Git, npm, Python, Docker, etc.). The \rtk smart\ command no longer uses local LLM models (candle-core/tokenizers) but now uses a fast heuristic analyzer. The \rtk read\ command now supports multiple files and new flags like \--head-lines\ and \--tail\_lines\. The \rtk ls\ command is now a proxy to the native \ls\ command with compact output. The \rtk init\ command now supports multiple AI agents (Claude, Cursor, Trae, Windsurf, Cline, etc.) via the \--agent\ flag.

src · high confidence

The hooks directory now provides native hook handlers for supported agents (such as Claude Code, Copilot, Cursor, Codex, and Vibe) instead of relying on external bash scripts. This change introduces agent-specific configuration files, documentation, and test suites within the \hooks/\ directory, while delegating all rewrite logic to the shared RTK Rust binary. Users benefit from improved performance, reduced dependencies (e.g., no longer requiring \jq\ for native handlers), and more robust command interception across a wider range of LLM agents.

hooks · high confidence

The Homebrew formula for rtk has been updated to reflect the project's move to the rtk-ai GitHub organization. Installation instructions and binary download URLs now point to rtk-ai/rtk instead of the previous pszymkowiak/rtk repository. Additionally, the license metadata has been changed from MIT to Apache 2.0, and the homepage URL has been updated to the official project site.

Formula · high confidence

Add test fixtures for git blob and tree parsing; Added multifail-skeleton test fixture; Added test fixtures for multi-module reactor diagnostics; Added test fixtures for multi-module skeleton; Expanded test coverage for core CLI behaviors and integrations.

The project has undergone a significant dependency and configuration overhaul. The license was changed from MIT to Apache-2.0, and the repository URL was updated to rtk-ai/rtk. The Rust edition was upgraded to 2024 with a minimum supported Rust version (MSRV) of 1.91. Local LLM inference capabilities (candle-core, tokenizers, hf-hub) were removed, reducing binary size and complexity. New dependencies were added to support structured output parsing (quick-xml), command tracking via SQLite (rusqlite), TOML configuration (toml, toml\_edit), and improved Windows console code page decoding (windows-sys, codepage, oem\_cp). The build system was also updated to use cargo-deb and cargo-generate-rpm for packaging, replacing the previous cargo-dist setup.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 70 (+17.0)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 75 (-25.3)
• Architecture 92 → 91 (-0.8)
• Maturity 82 → 88 (+6.1)
• Readiness 27 → 66 (+38.3)
• Security 65 → 68 (+2.1)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 26 more

• AggressiveFilter::filter (cognitive 24) (src/core/filter.rs)
• CargoTestHandler::compute_test_summary (cognitive 21) (src/cmds/rust/cargo_cmd.rs)
• ClassTooLong: Commands (src/main.rs)
• ClassTooLong: Tracker (src/core/tracking.rs)
• ClaudeProvider::discover_sessions_in_projects_dir (cognitive 18) (src/discover/provider.rs)
• ClaudeProvider::extract_commands (cognitive 37) (src/discover/provider.rs)
• ClaudeProvider::extract_commands (cyclomatic 17) (src/discover/provider.rs)
• Dependency advisory scan runs only on code events
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• DependencyState::format_compact (cognitive 16) (src/parser/formatter.rs)
• DependencyState::format_verbose (cognitive 17) (src/parser/formatter.rs)
• Documentation: no project overview (README.md)
• Duplicated block (10 lines × 2) (src/analytics/gain.rs)
• Duplicated block (10 lines × 2) (src/cmds/git/git_cmd.rs)
• Duplicated block (10 lines × 2) (src/cmds/js/lint_cmd.rs)
• Duplicated block (10 lines × 2) (src/cmds/system/json_cmd.rs)
• Duplicated block (10–11 lines × 2) (src/cmds/jvm/mvn_cmd.rs)
• Duplicated block (11 lines × 2) (src/cmds/cloud/aws_cmd.rs)
• Duplicated block (11 lines × 2) (src/cmds/dotnet/dotnet_cmd.rs)
• Duplicated block (11 lines × 2) (src/cmds/git/gh_cmd.rs)
• …and 575 more

• 300 commits — 123 feature/other, 177 fixes

• src/cmds — 101 commits
• (repo) — 74 commits
• src/core — 39 commits
• src/hooks — 23 commits
• (root) — 13 commits
• src/discover — 9 commits
• docs/guide — 6 commits
• docs/usage — 4 commits
• src/analytics — 4 commits
• .github/workflows — 3 commits
• src/main.rs — 3 commits
• .claude/rules — 2 commits
• docs/TELEMETRY.md — 2 commits
• tests/fixtures — 2 commits
• tests/git_show_blob_differential_test.rs — 2 commits
• tests/guard_integration_test.rs — 2 commits
• tests/read_window_bytes_test.rs — 2 commits
• tests/run_shell_test.rs — 2 commits
• src/filters — 1 commit
• tests/grep_faithful_format_test.rs — 1 commit

• fix: Merge branch 'develop' into fix/global-init-create-claude-config-dir
• fix: Merge branch 'develop' into fix/global-init-create-claude-config-dir
• fix: Merge branch 'develop' into fix/minimal-python-multiline-string
• fix: Merge develop into fix/init-agent-cursor-directory
• fix: Merge origin/develop into fix/pipe-safe-consummer-and-slim-instructions
• fix: Merge pull request #1122 from carlosdagos/fix/gh-pr-no-early-exit
• fix: Merge pull request #1298 from rtk-ai/fix/tracking-weighted-aggregations
• fix: Merge pull request #1422 from JackDanger/fix/suppress-hook-warn-during-init
• fix: Merge pull request #2397 from hgunduzoglu/fix/minimal-filter-comment-detection
• fix: Merge pull request #2515 from allanbatista/codex/fix-native-test-expression
• fix: Merge pull request #2521 from elite133713/fix/global-init-create-claude-config-dir
• fix: Merge pull request #2709 from guyoron1/fix/gradle-filter-regex-match
• fix: Merge pull request #3000 from rNoz/fix/init-agent-cursor-directory
• fix: Merge pull request #3083 from lntutor/fix/2669-ruff-subcommand-routing
• fix: Merge pull request #3087 from lntutor/fix/2663-npm-subcommands
• fix: Merge pull request #3258 from breisnerlopez/fix/grep-l-max-len-collision
• fix: Merge pull request #3275 from breisnerlopez/fix/pnpm-strip-global-opts
• fix: Merge pull request #3336 from imkp1/fix/minimal-python-multiline-string
• fix: Merge pull request #3343 from rtk-ai/fix/pipe-safe-consummer-and-slim-instructions
• fix: Merge pull request #3542 from uuzzrm/fix/gh-checks-watch-deduplicate
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rtk-ai/rtk was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.