一次 30 分鐘的 Claude Code 開發 Session：

未使用 RTK：
  ls / tree    → 10 次呼叫 × ~200 tokens = 2,000 tokens
  cat / read   → 20 次呼叫 × ~2,000 tokens = 40,000 tokens
  grep / rg    → 8 次呼叫 × ~2,000 tokens = 16,000 tokens
  git status   → 10 次呼叫 × ~300 tokens = 3,000 tokens
  git diff     → 5 次呼叫 × ~2,000 tokens = 10,000 tokens
  cargo test   → 5 次呼叫 × ~5,000 tokens = 25,000 tokens
  ────────────────────────────────────────────
  合計：~118,000 tokens

使用 RTK 後：
  合計：~23,900 tokens（節省 80%）

  未使用 RTK：                                使用 RTK：

  Claude  ──git status──>  Shell  ──>  git     Claude  ──git status──>  RTK  ──>  git
    ^                                   |        ^                      |          |
    |        ~2,000 tokens (raw)        |        |   ~200 tokens        | filter   |
    +───────────────────────────────────+        +─────── (filtered) ───+──────────+

Claude Code          settings.json        rtk-rewrite.sh        RTK binary
     │                    │                     │                    │
     │  "git status"      │                     │                    │
     │ ──────────────────►│                     │                    │
     │                    │  PreToolUse trigger  │                    │
     │                    │ ───────────────────►│                    │
     │                    │                     │  rewrite command   │
     │                    │                     │  → rtk git status  │
     │                    │◄────────────────────│                    │
     │  execute: rtk git status                                      │
     │ ─────────────────────────────────────────────────────────────►│
     │                                                               │ filter
     │  "3 modified, 1 untracked ✓"                                  │
     │◄──────────────────────────────────────────────────────────────│

# ~/.config/rtk/config.toml
[tee]
enabled = true          # 失敗時保存原始輸出（預設：true）
mode = "failures"       # "failures"（預設）| "always" | "never"

$ rtk cargo test
FAILED: 2/15 tests
[full output: ~/.local/share/rtk/tee/1707753600_cargo_test.log]

# ~/.config/rtk/filters/custom.toml
# 範例：自訂 bundle install 過濾規則

[[rules]]
match = "^Using "           # 匹配以 "Using " 開頭的行
action = "remove"           # 移除匹配行

[[rules]]
match = "^Bundle complete"  # 匹配安裝完成訊息
action = "keep"             # 保留此行

[summary]
template = "ok bundle: complete"   # 全部通過時的簡潔輸出

# 官方 Homebrew 安裝（最簡單）
brew install rtk

# 驗證安裝
rtk --version
# 應顯示：rtk 0.42.x

# 初始化（為 AI 工具設定 Hook）
rtk init -g                          # Claude Code（預設）
rtk init -g --copilot                # GitHub Copilot
rtk init -g --gemini                 # Gemini CLI
rtk init -g --codex                  # OpenAI Codex
rtk init -g --agent cursor           # Cursor
rtk init -g --agent windsurf         # Windsurf
rtk init -g --agent cline            # Cline / Roo Code
rtk init -g --agent kilocode         # Kilo Code
rtk init -g --agent antigravity      # Google Antigravity
rtk init -g --agent hermes           # Hermes
rtk init -g --agent pi               # Pi Agent

# 一鍵安裝腳本（安裝至 ~/.local/bin）
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# 確保 PATH 包含安裝目錄
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc   # Bash
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc    # Zsh
source ~/.bashrc  # 或 source ~/.zshrc

# ⚠️ 重要：使用 --git 從 GitHub 安裝，而非 crates.io
# crates.io 上的 "rtk" 是另一個套件（Rust Type Kit），會產生名稱衝突
cargo install --git https://github.com/rtk-ai/rtk

# 驗證
rtk --version
rtk gain    # 確認是 RTK (Rust Token Killer)，而非其他同名套件

# 方法 1：下載預編譯二進位檔
# 至 https://github.com/rtk-ai/rtk/releases 下載 rtk-x86_64-pc-windows-msvc.zip
# 解壓縮後將 rtk.exe 放入 PATH

# 方法 2：透過 Cargo 安裝（需先安裝 Rust）
cargo install --git https://github.com/rtk-ai/rtk

# 設定 PATH（PowerShell）
$env:PATH += ";$env:USERPROFILE\.cargo\bin"

# 永久設定（加入 PowerShell Profile）
Add-Content $PROFILE '$env:PATH += ";$env:USERPROFILE\.cargo\bin"'

# 初始化（Falls back to CLAUDE.md 模式）
rtk init -g

# 如果尚未安裝 Scoop
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

# 透過 Scoop 安裝（若社群已收錄）
scoop bucket add extras
scoop install rtk

# 先確保已安裝 Rust
winget install Rustlang.Rust.MSVC

# 從 GitHub 原始碼安裝（推薦，避免名稱衝突）
cargo install --git https://github.com/rtk-ai/rtk

# 驗證
rtk --version
rtk gain    # 必須顯示 Token 統計，而非 "command not found"

# 方法 1：Quick Install（推薦）
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# 安裝至 ~/.local/bin，如需加入 PATH：
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# 方法 2：Cargo 安裝
sudo apt update && sudo apt install -y build-essential pkg-config libssl-dev
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
cargo install --git https://github.com/rtk-ai/rtk

# 方法 3：預編譯二進位檔
wget https://github.com/rtk-ai/rtk/releases/latest/download/rtk-x86_64-unknown-linux-musl.tar.gz
tar xzf rtk-x86_64-unknown-linux-musl.tar.gz
sudo mv rtk /usr/local/bin/

# 安裝編譯依賴
sudo dnf groupinstall -y "Development Tools"
sudo dnf install -y openssl-devel

# Cargo 安裝
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
cargo install --git https://github.com/rtk-ai/rtk

# 或使用預編譯二進位檔
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# Homebrew 安裝（最推薦的方式）
brew install rtk

# 驗證
rtk --version
rtk gain

# 從 GitHub 安裝
cargo install --git https://github.com/rtk-ai/rtk

# Apple Silicon (M1/M2/M3)
# Cargo 會自動偵測架構，無需特別設定

# Intel Mac
wget https://github.com/rtk-ai/rtk/releases/latest/download/rtk-x86_64-apple-darwin.tar.gz
tar xzf rtk-x86_64-apple-darwin.tar.gz
sudo mv rtk /usr/local/bin/

# Apple Silicon (M1/M2/M3)
wget https://github.com/rtk-ai/rtk/releases/latest/download/rtk-aarch64-apple-darwin.tar.gz
tar xzf rtk-aarch64-apple-darwin.tar.gz
sudo mv rtk /usr/local/bin/

# Dockerfile
FROM rust:1.80-slim AS builder
RUN cargo install --git https://github.com/rtk-ai/rtk

FROM debian:bookworm-slim
COPY --from=builder /usr/local/cargo/bin/rtk /usr/local/bin/rtk
RUN rtk --version

// .devcontainer/devcontainer.json
{
  "name": "Dev with RTK",
  "image": "mcr.microsoft.com/devcontainers/base:ubuntu",
  "postCreateCommand": "curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh && export PATH=\"$HOME/.local/bin:$PATH\" && rtk init -g",
  "customizations": {
    "vscode": {
      "settings": {
        "terminal.integrated.env.linux": {
          "PATH": "${env:HOME}/.local/bin:${env:PATH}"
        }
      }
    }
  }
}

# 1. 確保 WSL2 已安裝
wsl --install

# 2. 進入 WSL2 環境
wsl

# 3. 安裝 RTK（與 Linux 相同）
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# 4. 初始化（完整 Hook 支援）
rtk init -g

# 5. 驗證
rtk --version
rtk gain
rtk ls .

# 設定 HTTP/HTTPS Proxy
export HTTP_PROXY=http://proxy.company.com:8080
export HTTPS_PROXY=http://proxy.company.com:8080
export NO_PROXY=localhost,127.0.0.1,.company.com

# Cargo Proxy 設定
# ~/.cargo/config.toml
cat >> ~/.cargo/config.toml << 'EOF'
[http]
proxy = "http://proxy.company.com:8080"

[https]
proxy = "http://proxy.company.com:8080"
EOF

# 透過 Proxy 安裝
cargo install --git https://github.com/rtk-ai/rtk

# 若 Git 也需要 Proxy
git config --global http.proxy http://proxy.company.com:8080
git config --global https.proxy http://proxy.company.com:8080

# === 在可上網的機器上準備 ===

# 方法 1：下載預編譯二進位檔
wget https://github.com/rtk-ai/rtk/releases/latest/download/rtk-x86_64-unknown-linux-musl.tar.gz

# 方法 2：下載原始碼打包
git clone https://github.com/rtk-ai/rtk.git
cd rtk
cargo vendor          # 下載所有依賴至 vendor/
tar czf rtk-source-with-deps.tar.gz .

# === 在離線機器上安裝 ===

# 方法 1：直接使用二進位檔
tar xzf rtk-x86_64-unknown-linux-musl.tar.gz
sudo mv rtk /usr/local/bin/

# 方法 2：從原始碼編譯
tar xzf rtk-source-with-deps.tar.gz
cd rtk
# 建立 .cargo/config.toml 使用 vendor 目錄
mkdir -p .cargo
cat > .cargo/config.toml << 'EOF'
[source.crates-io]
replace-with = "vendored-sources"

[source.vendored-sources]
directory = "vendor"
EOF

cargo build --release
sudo cp target/release/rtk /usr/local/bin/

# 1. 版本檢查
rtk --version
# 預期輸出：rtk 0.40.0（或更新版本）

# 2. 功能驗證（最重要！確認是正確的 RTK）
rtk gain
# 預期輸出：Token savings 統計（首次使用會顯示空統計）

# 3. 基本功能測試
rtk ls .                    # 精簡的目錄列表
rtk git status              # 精簡的 git status
rtk read README.md          # 精簡的檔案讀取

# 4. 檢查 Hook 安裝狀態
rtk init --show
# 預期輸出：顯示 Hook 安裝狀態與路徑

# ✗ 錯誤：這會安裝 Crates.io 的 Rust Type Kit
cargo install rtk

# ✓ 正確：從 GitHub 安裝 RTK (Rust Token Killer)
cargo install --git https://github.com/rtk-ai/rtk

# ✓ 最推薦：使用 Homebrew
brew install rtk

# 執行 rtk gain，如果顯示 Token 統計報表，則是正確的 RTK
rtk gain

# 如果顯示 "unknown command" 或無反應，則可能安裝了錯誤的套件

# === Before（git push 原始輸出）=== 
# 15 行, ~200 tokens
$ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 1.23 KiB | 1.23 MiB/s, done.
Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (2/2), completed with 2 local objects.
To https://github.com/user/repo.git
   abc1234..def5678  main -> main

# === After（RTK 過濾後）===
# 1 行, ~10 tokens
$ rtk git push
ok main

# === Before（ESLint 原始輸出）===
# 100+ 行
/src/App.tsx:5:10 - error: 'useState' is defined but never used (no-unused-vars)
/src/App.tsx:12:5 - error: Missing semicolon (semi)
/src/components/Header.tsx:3:8 - error: 'React' is defined but never used (no-unused-vars)
/src/components/Header.tsx:15:3 - error: Missing semicolon (semi)
/src/utils/api.ts:8:1 - error: 'console' is not allowed (no-console)
... (省略 95 行)

# === After（RTK 過濾後）===
# 5 行
$ rtk lint
no-unused-vars: 23 issues
semi: 45 issues
no-console: 12 issues
prefer-const: 8 issues
Total: 88 issues in 15 files

# 讀取大型檔案時自動截斷
rtk read large-file.log

# 配合 Tee Mode 保留完整輸出
# 截斷輸出送給 AI，完整輸出存至 tee 檔案

# === Before（Docker 日誌原始輸出）===
[ERROR] Connection refused to database at 10.0.0.5:5432
[ERROR] Connection refused to database at 10.0.0.5:5432
[ERROR] Connection refused to database at 10.0.0.5:5432
[INFO] Retrying connection...
[ERROR] Connection refused to database at 10.0.0.5:5432
[ERROR] Connection refused to database at 10.0.0.5:5432

# === After（RTK 過濾後）===
$ rtk docker logs my-app
[ERROR] Connection refused to database at 10.0.0.5:5432 (×5)
[INFO] Retrying connection...

# ~/.config/rtk/config.toml
[tee]
enabled = true          # 預設啟用
mode = "failures"       # "failures"（僅失敗時）| "always" | "never"

$ rtk cargo test
FAILED: 2/15 tests
  test_edge_case: assertion failed at src/lib.rs:45
  test_overflow: panic at src/utils.rs:18
[full output: ~/.local/share/rtk/tee/1707753600_cargo_test.log]

# AI 助手可直接讀取完整輸出
$ cat ~/.local/share/rtk/tee/1707753600_cargo_test.log

# 標準模式
$ rtk git status
3 files modified, 1 file untracked

# Ultra Compact 模式
$ rtk git status -u
3M 1? ✓

# 標準模式
$ rtk gh pr view 42
Pull request #42 successfully merged

# Ultra Compact 模式
$ rtk gh pr view 42 -u
✓ PR #42 merged

# 摘要統計
$ rtk gain
┌──────────────────────────────────────┐
│ Token Savings Report (90 days)       │
├──────────────────────────────────────┤
│ Commands executed:  1,234            │
│ Average savings:    78.5%            │
│ Total tokens saved: 45,678           │
│ Total exec time:    8m50s            │
│                                      │
│ Top commands:                        │
│   • rtk git status    (234 uses)     │
│   • rtk lint          (156 uses)     │
│   • rtk test          (89 uses)      │
└──────────────────────────────────────┘

# ASCII 圖表（近 30 天）
$ rtk gain --graph

# 每日明細
$ rtk gain --daily

# JSON 匯出（供儀表板使用）
$ rtk gain --all --format json

# 掃描當前專案
$ rtk discover
Missed savings opportunities:
  git log (called 12 times without rtk) → est. 3,600 tokens saveable
  npm test (called 5 times without rtk) → est. 12,500 tokens saveable
  docker ps (called 8 times without rtk) → est. 1,440 tokens saveable

# 掃描所有專案，最近 7 天
$ rtk discover --all --since 7

rtk gain                    # 摘要統計（90 天）
rtk gain --graph            # ASCII 趨勢圖（30 天）
rtk gain --history          # 最近指令歷史
rtk gain --daily            # 每日明細（逐日分解）
rtk gain --weekly           # 每週彙總報告
rtk gain --all --format json  # JSON 匯出

# 檢視 RTK 在各 Session 的採用率
$ rtk session

# 搭配 discover 找出未覆蓋的指令
$ rtk discover

# 標準模式
$ rtk smart src/main.rs
# 輸出：2 行啟發式摘要，包含主要函式簽名和結構

# 適合用於大型專案探索
$ find src -name "*.rs" -exec rtk smart {} \;

# 預設模式（移除部分噪音）
$ rtk read src/app.ts

# Aggressive 模式（僅保留簽名，移除函式主體）
$ rtk read src/app.ts -l aggressive

# 適合初步了解程式碼結構
# FilterLevel::None       → 保留全部 (0%)
# FilterLevel::Minimal    → 移除註解 (20-40%)
# FilterLevel::Aggressive → 移除函式主體 (60-90%)

# 通用測試包裝
$ rtk test cargo test        # Rust 測試 (-90%)
$ rtk test npm test          # Node.js 測試 (-90%)
$ rtk test pytest            # Python 測試 (-90%)

# 專用指令
$ rtk cargo test             # Cargo 測試
$ rtk jest                   # Jest 測試 (-99.6%)
$ rtk vitest                 # Vitest 測試 (-99.6%)
$ rtk pytest                 # Pytest 測試 (-90%)
$ rtk go test                # Go 測試 (NDJSON, -90%)
$ rtk rake test              # Ruby minitest (-90%)
$ rtk rspec                  # RSpec 測試 (-60%+)

# 僅顯示錯誤
$ rtk err <any-command>      # 過濾任何指令的錯誤輸出

# === Before（cargo test 原始輸出，200+ 行）===
running 15 tests
test utils::test_parse ... ok
test utils::test_format ... ok
test utils::test_validate ... ok
... (12 more passing tests)
test edge::test_edge_case ... FAILED
test overflow::test_overflow ... FAILED

failures:
  test_edge_case: assertion failed: expected 42, got 41
    at src/edge.rs:45

  test_overflow: thread panicked at 'overflow'
    at src/utils.rs:18

# === After（rtk test 輸出，~20 行）===
$ rtk cargo test
FAILED: 2/15 tests
  test_edge_case: assertion failed
  test_overflow: panic at utils.rs:18

$ rtk gh pr list            # 精簡 PR 列表
$ rtk gh pr view 42         # PR 詳情 + checks
$ rtk gh issue list         # 精簡 Issue 列表
$ rtk gh run list           # Workflow 執行狀態

$ rtk git status            # 精簡狀態
$ rtk git log -n 10         # 單行 commit
$ rtk git diff              # 精簡 diff
$ rtk git add .             # → "ok"
$ rtk git commit -m "msg"   # → "ok abc1234"
$ rtk git push              # → "ok main"
$ rtk git pull              # → "ok 3 files +10 -2"

rtk ls [PATH] [OPTIONS]

# 基本用法
$ rtk ls .
my-project/
├── src/ (8 files)
│   ├── main.rs
│   └── lib.rs
├── tests/ (3 files)
├── Cargo.toml
└── README.md

# Ultra Compact
$ rtk ls . -u
my-project/ src/(8) tests/(3) Cargo.toml README.md

# ls -la（45 行, ~800 tokens）        # rtk ls（12 行, ~150 tokens）
drwxr-xr-x  15 user staff 480 ...     my-project/
-rw-r--r--   1 user staff 1234 ...     ├── src/ (8 files)
-rw-r--r--   1 user staff 567 ...      │   ├── main.rs
...（42 more lines）                    └── Cargo.toml

rtk read <FILE> [OPTIONS]

# 預設讀取（移除註解）
$ rtk read src/main.rs

# Aggressive 模式（僅保留函式簽名）
$ rtk read src/main.rs -l aggressive
fn calculate_total(items: &[Item]) -> i32 { ... }
fn validate_input(s: &str) -> Result<(), Error> { ... }
fn main() { ... }

# 用於快速了解大型檔案結構
$ rtk read src/server.ts -l aggressive

rtk smart <FILE> [OPTIONS]

# 單一檔案摘要
$ rtk smart src/server.ts
Express server with REST API endpoints for user management
Exports: createServer(), startListening(), middleware setup

# 批次掃描整個目錄
$ find src -name "*.ts" -exec rtk smart {} \;

rtk test <COMMAND> [ARGS...]

rtk jest                    # Jest (-99.6%)
rtk vitest                  # Vitest (-99.6%)
rtk playwright test         # Playwright E2E (-94%)
rtk pytest                  # Python pytest (-90%)
rtk go test                 # Go tests NDJSON (-90%)
rtk cargo test              # Cargo tests (-90%)
rtk rake test               # Ruby minitest (-90%)
rtk rspec                   # RSpec (-60%+)
rtk err <cmd>               # 任何指令的錯誤過濾

# 所有測試通過
$ rtk cargo test
ok: 15/15 tests passed

# 有失敗測試
$ rtk cargo test
FAILED: 2/15 tests
  test_edge_case: assertion failed at src/lib.rs:45
  test_overflow: panic at src/utils.rs:18
[full output: ~/.local/share/rtk/tee/1707753600_cargo_test.log]

# Jest 測試
$ rtk jest
FAILED: 1/45 tests
  UserService.test.ts > should validate email
    Expected: true, Received: false

rtk git <SUBCOMMAND> [ARGS...]

rtk git status              # 精簡狀態
rtk git log [-n N]          # 單行 commit 日誌
rtk git diff [FILE]         # 精簡 diff
rtk git add [FILE...]       # → "ok"
rtk git commit -m "msg"     # → "ok abc1234"
rtk git push                # → "ok main"
rtk git pull                # → "ok 3 files +10 -2"

# 完整工作流程
$ rtk git status
3 modified, 1 untracked

$ rtk git add .
ok

$ rtk git commit -m "fix: resolve edge case in parser"
ok abc1234

$ rtk git push
ok main

rtk gh <SUBCOMMAND> [ARGS...]

$ rtk gh pr list
#42  fix: parser edge case    main ← feature/parser    ✓ checks passed
#41  feat: add caching        main ← feature/cache     ⏳ checks running
#39  docs: update readme      main ← docs/readme       ✓ merged

$ rtk gh issue list
#100  [bug] Memory leak in worker pool    high    open
#98   [feat] Add WebSocket support        medium  open
#95   [docs] API reference outdated       low     open

$ rtk gh run list
✓ CI Pipeline    #456    main    2m30s    success
✗ Deploy Staging #455    main    5m12s    failure
⏳ CI Pipeline   #457    feat/x  running

rtk gain [OPTIONS]

# 基本報告
$ rtk gain
Token Savings Report (90 days)
  Commands: 1,234
  Avg savings: 78.5%
  Total saved: 45,678 tokens

# 每週彙總
$ rtk gain --weekly

# JSON 匯出（供團隊儀表板）
$ rtk gain --all --format json > /path/to/dashboard/data.json

rtk discover [OPTIONS]

$ rtk discover --all --since 7
Projects with missed savings:
  /home/user/project-a:
    git log (12x) → ~3,600 tokens saveable
    npm test (5x) → ~12,500 tokens saveable
  
  /home/user/project-b:
    docker ps (8x) → ~1,440 tokens saveable
    kubectl logs (3x) → ~4,500 tokens saveable

rtk session [OPTIONS]

$ rtk session
Session Analysis:
  Session #1 (2h 15m): 87% RTK coverage (42/48 commands)
  Session #2 (1h 30m): 92% RTK coverage (33/36 commands)

  Missed commands:
    - curl (3x) → consider: rtk curl
    - psql (2x) → consider: rtk psql

rtk docker <SUBCOMMAND> [ARGS...]

$ rtk docker ps             # 精簡容器列表
$ rtk docker images         # 精簡映像列表
$ rtk docker logs <name>    # 去重複化的日誌
$ rtk docker compose ps     # Compose 服務狀態

rtk kubectl <SUBCOMMAND> [ARGS...]

$ rtk kubectl pods          # 精簡 Pod 列表
$ rtk kubectl logs <pod>    # 去重複化的 Pod 日誌
$ rtk kubectl services      # 精簡 Service 列表

rtk aws <SERVICE> <SUBCOMMAND> [ARGS...]

$ rtk aws sts get-caller-identity    # 單行身份資訊
$ rtk aws ec2 describe-instances     # 精簡實例列表
$ rtk aws lambda list-functions      # 名稱/Runtime/記憶體（移除 secrets）
$ rtk aws logs get-log-events        # 僅保留時間戳 + 訊息
$ rtk aws cloudformation describe-stack-events  # 失敗優先排序
$ rtk aws dynamodb scan              # 解包型別標註
$ rtk aws iam list-roles             # 移除 policy documents
$ rtk aws s3 ls                      # 截斷 + tee 還原

# 精簡 find（Tree Compression，按目錄彙總）
$ rtk find . -name "*.rs"
# → src/ (12 files), tests/ (5 files), benches/ (2 files)

# 精簡 grep（Grouping by Pattern，按檔案/模式分組）
$ rtk grep -rn "TODO" src/
# → src/main.rs: 3 matches
#   src/utils.rs: 1 match

# 精簡 diff（Stats Extraction）
$ rtk diff file_a file_b
# → +12/-5, 3 sections changed

# JSON 結構分析（Structure Only，僅保留 Key + 型別）
$ rtk json config.json
# → { "database": {...}, "server": {...}, "logging": {...} }

# 日誌去重複化（Deduplication）
$ rtk log app.log
# → [ERROR] Connection timeout (×15)
#   [WARN] Slow query detected (×8)

# 環境變數精簡（移除敏感值）
$ rtk env
# → 12 vars: PATH, HOME, SHELL, LANG, ...

# 依賴分析
$ rtk deps
# → 45 dependencies, 3 outdated, 1 vulnerable

# 通用代理模式（對任意指令套用基本壓縮）
$ rtk proxy -- my-custom-command --args

# HTTP 回應精簡
$ rtk curl https://api.example.com/users
# → 200 OK, 45 items (JSON schema: {id, name, email})

# 下載精簡（Progress Filtering，移除進度條）
$ rtk wget https://example.com/large-file.tar.gz
# → ✓ Downloaded large-file.tar.gz (234 MB)

# 摘要模式
$ rtk summary "any long text or command output"

~/.claude/
├── hooks/
│   └── rtk-rewrite.sh          # Hook 腳本（thin delegator）
├── RTK.md                      # RTK 指示文件（~10 行）
├── CLAUDE.md                   # Claude 設定（含 @RTK.md 參照）
├── settings.json               # Hook 註冊
└── settings.json.bak           # 備份

# 方法 1：推薦的全域設定（Hook + RTK.md）
rtk init -g

# 方法 2：自動化（不提示）
rtk init -g --auto-patch

# 方法 3：僅安裝 Hook（零 Context Token 開銷）
rtk init -g --hook-only

# 方法 4：僅本地專案（無 Hook，137 行 CLAUDE.md）
rtk init

# 驗證安裝
rtk init --show

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hook": "~/.claude/hooks/rtk-rewrite.sh"
      }
    ]
  }
}

# ~/.bashrc 或 ~/.zshrc
# 為常用指令建立 alias
alias ls='rtk ls'
alias grep='rtk grep'
alias cat='rtk read'

# 或者使用 function 包裝
git() {
    if command -v rtk &> /dev/null; then
        rtk git "$@"
    else
        command git "$@"
    fi
}

# Session 開始前
$ rtk gain
Commands: 0, Total saved: 0

# ... 30 分鐘的開發工作 ...
# Claude Code 自動使用 rtk git status (10x)
# Claude Code 自動使用 rtk read (20x)
# Claude Code 自動使用 rtk cargo test (5x)

# Session 結束後
$ rtk gain
Commands: 35
Average savings: 82.3%
Total tokens saved: 94,100
Estimated cost saved: $0.28

# 在 CLAUDE.md 或 RTK.md 中加入指示
# "When exploring unfamiliar code, use rtk read -l aggressive"
rtk read src/main.rs -l aggressive    # 僅看函式簽名
rtk smart src/lib.rs                   # 兩行摘要

# ~/.config/rtk/config.toml
[hooks]
exclude_commands = ["curl", "playwright", "ssh"]

# 在大型專案中，Context Window 壓力大時啟用
rtk ls . -u          # 極度精簡的目錄結構
rtk git log -10 -u   # 極度精簡的 commit 日誌

Main Agent ─── rtk git status ───► 精簡輸出
    │
    ├── Sub-Agent 1 ─── rtk cargo test ───► 精簡輸出
    │
    └── Sub-Agent 2 ─── rtk lint ───► 精簡輸出

所有 Agent 共享同一個 Hook → 100% 覆蓋率

# 初始化 Copilot 整合
rtk init -g --copilot

# 這會設定：
# - PreToolUse hook 用於 transparent rewrite
# - RTK.md 指示檔

// .vscode/settings.json
{
  "terminal.integrated.env.linux": {
    "PATH": "${env:HOME}/.local/bin:${env:PATH}"
  },
  "terminal.integrated.env.osx": {
    "PATH": "${env:HOME}/.local/bin:${env:PATH}"
  },
  "terminal.integrated.env.windows": {
    "PATH": "${env:USERPROFILE}\\.cargo\\bin;${env:PATH}"
  }
}

<!-- 在 .github/copilot-instructions.md 中加入 -->
## RTK Integration

When executing terminal commands, prefer using `rtk` prefix:
- Use `rtk git status` instead of `git status`
- Use `rtk ls .` instead of `ls -la`
- Use `rtk read <file>` instead of `cat <file>`
- Use `rtk cargo test` instead of `cargo test`

This reduces token consumption by 60-90%.

# 探索專案結構時
"Use rtk ls to show the project structure"

# 檢查 git 狀態時
"Run rtk git status to see current changes"

# 執行測試時
"Use rtk test to run tests and show only failures"

# 1. 確保 RTK 在 PATH 中
rtk --version

# 2. 設定 Shell Alias（可選）
echo 'alias gs="rtk git status"' >> ~/.bashrc
echo 'alias gl="rtk git log -10"' >> ~/.bashrc
echo 'alias gd="rtk git diff"' >> ~/.bashrc

# 3. 在 Copilot 終端機中直接使用
rtk ls .                    # Copilot 看到精簡的目錄結構
rtk git status              # Copilot 看到精簡的 git 狀態
rtk cargo test              # Copilot 只看到失敗的測試

# 全域設定（推薦）
rtk init -g --copilot

# 個別專案設定
cd /path/to/project
rtk init    # 僅影響當前專案

# 在 Monorepo 根目錄初始化
cd /path/to/monorepo
rtk init

# RTK 會自動偵測套件管理器
# pnpm-lock.yaml → pnpm exec
# yarn.lock → yarn exec
# 預設 → npx

# 初始化 Cursor 整合
rtk init -g --agent cursor

# 這會設定 hooks.json 中的 preToolUse hook

# .cursorrules

## Terminal Commands
- Always use `rtk` prefix for shell commands
- Use `rtk git status` instead of `git status`
- Use `rtk ls .` instead of `ls -la`
- Use `rtk read <file>` instead of `cat <file>`
- Use `rtk test <cmd>` for running tests

## Token Optimization
- Prefer `rtk smart <file>` for initial file exploration
- Use `rtk read <file> -l aggressive` for code structure overview
- Use `rtk err <cmd>` to filter only errors from any command

# 初始化 Gemini CLI 整合
rtk init -g --gemini

# 產生 BeforeTool hook 設定
# Gemini CLI 使用 BeforeTool hook 機制攔截指令

# 初始化 Codex 整合
rtk init -g --codex

# 產生 AGENTS.md + RTK.md 指示檔案

# Windsurf 整合（project-scoped）
rtk init --agent windsurf
# 產生 .windsurfrules 設定檔

# Cline / Roo Code 整合（project-scoped）
rtk init --agent cline
# 產生 .clinerules 設定檔

# OpenCode 整合
rtk init -g --opencode
# 使用 TypeScript Plugin（tool.execute.before）攔截指令

# OpenClaw 整合
# OpenClaw 作為 Cursor/VS Code 插件，透過插件機制整合

# Hermes 整合
rtk init --agent hermes
# 使用 Python adapter 整合

# Kilo Code 整合
rtk init --agent kilocode
# 產生 .kilocode/rules/rtk-rules.md 規則檔

# Google Antigravity 整合
rtk init --agent antigravity
# 產生 .agents/rules/antigravity-rtk-rules.md 規則檔

# Pi Agent 整合
rtk init -g --agent pi
# 最新加入的 agent 支援

# Step 1：了解整體結構（~150 tokens vs ~3,000 tokens）
rtk ls . -u
src/ main/(120) test/(45) resources/(8)
pom.xml build.gradle

# Step 2：批次掃描所有 Java 檔案（每檔 ~20 tokens vs ~500 tokens）
find src -name "*.java" | head -20 | xargs -I {} rtk smart {}

# Step 3：了解核心類別的 API
rtk read src/main/java/com/legacy/core/Engine.java -l aggressive
# 輸出：僅函式簽名，60-90% 壓縮

# Step 4：搜尋特定模式
rtk grep "deprecated" src/ 
# 輸出：按檔案分組，80% 壓縮

# 1. 依模組結構了解系統
rtk ls src/main/java/com/company/ -u

# 2. 分析依賴關係
rtk deps                    # 依賴摘要
rtk json package.json       # 結構化（僅 Key + 型別）

# 3. 了解進入點
rtk smart src/main/java/com/company/Application.java
rtk read src/main/java/com/company/Application.java -l aggressive

# 4. 追蹤 API 端點
rtk grep "@RequestMapping\|@GetMapping\|@PostMapping" src/
# 輸出按檔案分組，快速了解所有 API 端點

# 5. 分析設定檔
rtk read src/main/resources/application.yml
rtk json src/main/resources/application.json

# Phase 1：高層次結構（~200 tokens）
rtk ls . -u

# Phase 2：各模組摘要（~50 tokens/模組）
for dir in packages/*/; do
    echo "=== $dir ==="
    rtk smart "$dir/src/index.ts" 2>/dev/null
done

# Phase 3：關鍵檔案深入
rtk read packages/core/src/engine.ts -l aggressive
rtk read packages/api/src/routes.ts -l aggressive

# Phase 4：搜尋跨模組的共用模式
rtk grep "import.*from.*@company/core" packages/

# 1. 去重複化日誌（70-85% 壓縮）
rtk log /var/log/app/error.log
# [ERROR] Connection timeout to db:5432 (×847)
# [ERROR] Out of memory in worker-3 (×12)
# [WARN] Deprecated API call /v1/users (×2,341)

# 2. Docker 容器日誌
rtk docker logs my-app --tail 1000
# 去重複化 + 壓縮，僅顯示獨特的日誌行

# 3. Kubernetes Pod 日誌
rtk kubectl logs my-pod --tail 500
# 自動去重複化

# 4. 使用 summary 處理超長輸出
rtk summary "cat /var/log/app/access.log | head -10000"

# 1. 反編譯碼通常有大量自動產生的註解
# RTK 的 Code Filtering 會自動移除
rtk read decompiled/com/legacy/Service.java -l minimal
# 移除反編譯器產生的註解（20-40% 壓縮）

# 2. 僅查看公開 API
rtk read decompiled/com/legacy/Service.java -l aggressive
# 僅保留方法簽名（60-90% 壓縮）

# 3. 批次掃描反編譯結果
find decompiled/ -name "*.java" | xargs -I {} rtk smart {}
# 每個檔案只有 2 行摘要

# 1. API 回應（JSON 結構化）
rtk json api-response.json
# 僅顯示結構（Key + 型別），移除大量資料值

# 2. cURL 結果截斷
rtk curl https://api.example.com/v1/large-endpoint
# 自動截斷 + 保存完整輸出至 tee

# 3. Stack Trace 分析
rtk err "java -jar app.jar"
# 僅保留錯誤輸出，過濾正常啟動訊息

# 4. 環境變數過濾
rtk env -f SPRING
# 僅顯示匹配的環境變數

# Step 1：分析當前依賴
rtk deps
# 精簡的依賴列表，快速了解版本狀態

# Step 2：了解需要變更的檔案
rtk grep "javax\." src/main/java/
# 按檔案分組，找出所有 javax → jakarta 的變更點
# 輸出：
# javax imports found:
#   com/app/service/ (12 files)
#   com/app/controller/ (8 files)
#   com/app/entity/ (15 files)

# Step 3：逐檔分析差異
rtk read src/main/java/com/app/entity/User.java -l aggressive
# 僅看 import 和 annotation，快速判斷需要改什麼

# Step 4：執行升級後檢查建置
rtk cargo build   # 或 rtk test mvn compile
# 精簡的錯誤輸出，按檔案分組

# Step 5：執行測試
rtk test mvn test
# 僅顯示失敗的測試

# 1. 檢查過時的依賴
rtk pnpm outdated
# 精簡的過時套件列表（-80-90%）

# 2. 搜尋需要變更的 API
rtk grep "ReactDOM.render\|componentWillMount\|componentWillReceiveProps" src/
# 按檔案分組，找出所有 deprecated API

# 3. 升級後執行 lint
rtk lint
# 分組顯示：
#   react/no-deprecated: 15 issues
#   react-hooks/rules-of-hooks: 3 issues

# 4. 升級後執行 TypeScript 編譯
rtk tsc
# 分組顯示 TypeScript 錯誤：
#   src/components/ (8 errors)
#   src/hooks/ (3 errors)

# 5. 執行測試
rtk vitest
# 僅顯示失敗測試（-99.6%）

# 6. 執行 E2E 測試
rtk playwright test
# 僅顯示失敗測試（-94%）

# 搜尋需要遷移的 API
rtk grep "Vue.component\|Vue.directive\|this\.\$on\|this\.\$off" src/
# 分組結果快速定位需要變更的檔案

# 檢查 Composition API 遷移進度
rtk grep "defineComponent\|setup()\|ref(\|reactive(" src/

# 搜尋 deprecated 模式
rtk grep "HttpModule\|@angular/http\|ngDoCheck" src/
# 分組結果

# 執行 Angular 升級建議
rtk err "ng update @angular/core @angular/cli"

# 1. 檢查相容性
rtk deps
# 精簡的依賴清單

# 2. 找出 CommonJS / ESM 問題
rtk grep "require(\|module.exports" src/
# 按檔案分組

# 3. 升級後測試
rtk test npm test
# 僅顯示失敗

# 4. 檢查 deprecated API
rtk grep "Buffer(\|new Buffer\|url.parse" src/

# 1. 檢查 Clippy 警告
rtk cargo clippy
# 分組顯示 Clippy 建議（-80%）

# 2. 建置檢查
rtk cargo build
# 精簡的建置輸出（-80%）

# 3. 測試
rtk cargo test
# 僅失敗測試（-90%）

# 4. 依賴審計
rtk deps

# 1. 探索元件結構
rtk ls src/components/ -u
# src/components/ Header/(3) Footer/(2) Sidebar/(4) Dashboard/(8)

# 2. 了解元件 API
rtk read src/components/Dashboard/index.tsx -l aggressive
# export const Dashboard: FC<DashboardProps> = ({ ... }) => { ... }
# export interface DashboardProps { ... }

# 3. 開發後 lint 檢查
rtk lint
# no-unused-vars: 2 issues
# react-hooks/exhaustive-deps: 1 issue
# Total: 3 issues in 2 files

# 4. TypeScript 檢查
rtk tsc
# src/components/Dashboard/Chart.tsx (2 errors)
#   TS2345: Type 'string' is not assignable to type 'number'

# 5. 測試
rtk vitest
# ok: 45/45 tests passed

# 6. Prettier 格式化檢查
rtk prettier --check .
# 3 files need formatting

# Java / Spring Boot
rtk read src/main/java/com/app/controller/UserController.java -l aggressive
rtk grep "@Service\|@Repository\|@Controller" src/
rtk test mvn test
rtk err mvn compile

# Node.js / Express
rtk read src/routes/api.ts -l aggressive
rtk jest
rtk lint

# Python / FastAPI
rtk read src/main.py -l aggressive
rtk pytest
rtk ruff check

# 1. 資料庫 Schema
rtk read prisma/schema.prisma
rtk prisma generate      # 無 ASCII art（精簡）

# 2. API Routes
rtk ls src/server/api/ -u
rtk read src/server/api/routers/user.ts -l aggressive

# 3. 前端元件
rtk ls src/app/ -u
rtk read src/app/dashboard/page.tsx -l aggressive

# 4. 全端測試
rtk vitest               # 單元測試
rtk playwright test      # E2E 測試

# 5. 建置檢查
rtk next build           # Next.js 建置（精簡輸出）

# 多服務 Docker Compose 環境
rtk docker compose ps
# service-a  running  0.0.0.0:3001->3000
# service-b  running  0.0.0.0:3002->3000
# postgres   running  0.0.0.0:5432->5432
# redis      running  0.0.0.0:6379->6379

# 查看特定服務的日誌
rtk docker logs service-a --tail 100
# [INFO] Server started on port 3000 (×1)
# [INFO] Database connected (×1)
# [ERROR] Connection to service-b timeout (×12)

# 跨服務搜尋
for svc in service-a service-b service-c; do
    echo "=== $svc ==="
    rtk read $svc/src/index.ts -l aggressive
done

# pnpm Monorepo
rtk pnpm list             # 精簡依賴列表（-70%）
rtk pnpm outdated         # 過時套件（-80-90%）

# RTK 自動偵測套件管理器
# pnpm-lock.yaml → 使用 pnpm exec
# yarn.lock → 使用 yarn exec
# 預設 → 使用 npx

# 各套件概覽
rtk ls packages/ -u
# packages/ core/(15) api/(12) web/(25) mobile/(20) shared/(8)

# 套件依賴圖
rtk deps

# GitHub Actions 範例
name: CI with RTK
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install RTK
        run: |
          curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
          echo "$HOME/.local/bin" >> $GITHUB_PATH
      
      - name: Lint (with RTK token tracking)
        run: rtk lint
      
      - name: Test (with RTK token tracking)
        run: rtk test npm test
      
      - name: Build
        run: rtk next build
      
      - name: Token savings report
        run: rtk gain --format json > rtk-report.json
      
      - name: Upload RTK report
        uses: actions/upload-artifact@v4
        with:
          name: rtk-token-report
          path: rtk-report.json

# 容器管理
rtk docker ps                   # 精簡容器列表
rtk docker images               # 精簡映像列表
rtk docker logs <container>     # 去重複化日誌
rtk docker compose ps           # Compose 服務狀態

# 實務範例
$ rtk docker ps
CONTAINER    IMAGE             STATUS    PORTS
my-app       my-app:latest     Up 2h     0.0.0.0:3000->3000
postgres     postgres:16       Up 2h     0.0.0.0:5432->5432
redis        redis:7           Up 2h     0.0.0.0:6379->6379

# vs 原始 docker ps（大量額外資訊如 CONTAINER ID、CREATED 等）
# Token 節省：~80%

# Pod 管理
rtk kubectl pods                # 精簡 Pod 列表
rtk kubectl logs <pod>          # 去重複化日誌
rtk kubectl services            # 精簡 Service 列表

# 實務範例
$ rtk kubectl pods
NAME                        READY   STATUS    AGE
api-server-abc123           1/1     Running   2d
worker-def456               1/1     Running   2d
worker-ghi789               0/1     CrashLoop 5m  ←
postgres-jkl012             1/1     Running   5d

# 去重複化 Pod 日誌
$ rtk kubectl logs worker-ghi789
[ERROR] Out of memory: heap allocation failed (×47)
[INFO] Restart attempt (×12)
[ERROR] Failed to connect to service: api-server (×3)

# 身份驗證
rtk aws sts get-caller-identity
# arn:aws:iam::123456789:user/developer

# EC2 實例（精簡列表）
rtk aws ec2 describe-instances
# i-abc123  t3.medium  running  10.0.1.5
# i-def456  t3.large   running  10.0.1.6

# Lambda 函式（移除 secrets）
rtk aws lambda list-functions
# my-function  python3.12  128MB  30s timeout
# api-handler  nodejs20.x  256MB  60s timeout

# CloudWatch 日誌（僅時間戳 + 訊息）
rtk aws logs get-log-events --log-group /aws/lambda/my-function
# 2026-05-25T10:30:00 START RequestId: abc-123
# 2026-05-25T10:30:01 Processing 42 records
# 2026-05-25T10:30:02 END RequestId: abc-123

# CloudFormation 事件（失敗優先）
rtk aws cloudformation describe-stack-events --stack-name my-stack
# ✗ AWS::Lambda::Function  CREATE_FAILED  Resource limit exceeded
# ✓ AWS::IAM::Role         CREATE_COMPLETE
# ✓ AWS::S3::Bucket        CREATE_COMPLETE

# DynamoDB 掃描（解包型別標註）
rtk aws dynamodb scan --table-name users
# {id: "user-1", name: "Alice", age: 30}
# vs 原始 {"id": {"S": "user-1"}, "name": {"S": "Alice"}, "age": {"N": "30"}}

# RTK 目前未有專用的 Azure CLI 過濾器
# 但可使用通用的 proxy / summary 指令

# 通用代理模式（追蹤 Token）
rtk proxy az vm list --output table

# 摘要模式
rtk summary "az resource list --output table"

# JSON 結構化
az vm list --output json > /tmp/vms.json
rtk json /tmp/vms.json

# 與 Azure 類似，使用通用指令
rtk proxy gcloud compute instances list
rtk summary "gcloud run services list"

# JSON 結構化
gcloud projects list --format=json > /tmp/projects.json
rtk json /tmp/projects.json

# .github/workflows/ai-optimized-ci.yml
name: AI-Optimized CI

on:
  pull_request:
    branches: [main]

jobs:
  lint-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Install RTK
        run: |
          curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
          echo "$HOME/.local/bin" >> $GITHUB_PATH
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20
      
      - name: Install dependencies
        run: npm ci
      
      - name: Lint
        run: rtk lint
      
      - name: Type Check
        run: rtk tsc
      
      - name: Test
        run: rtk vitest
      
      - name: Build
        run: rtk next build
      
      # 匯出 Token 節省報告
      - name: RTK Report
        if: always()
        run: |
          rtk gain --format json > rtk-report.json
          echo "### RTK Token Savings" >> $GITHUB_STEP_SUMMARY
          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
          rtk gain >> $GITHUB_STEP_SUMMARY
          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY

# .gitlab-ci.yml
stages:
  - lint
  - test
  - build

variables:
  RTK_VERSION: "latest"

before_script:
  - curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
  - export PATH="$HOME/.local/bin:$PATH"

lint:
  stage: lint
  script:
    - rtk lint
    - rtk tsc

test:
  stage: test
  script:
    - rtk vitest
    - rtk gain

build:
  stage: build
  script:
    - rtk next build
  artifacts:
    paths:
      - .next/

# Cargo 測試（Failure Focus，僅顯示失敗）
$ rtk cargo test
# FAILED: 2/15 tests → 94-99% 壓縮

# Cargo 建置（Error Only）
$ rtk cargo build
# → "ok" 或僅錯誤訊息

# Cargo Clippy（Grouping by Pattern）
$ rtk cargo clippy
# → 按 lint 規則分組，85%+ 壓縮

# Ruff（JSON/Text 雙模式）
$ rtk ruff check src/
# JSON API 解析 → 按規則分組 → 80%+ 壓縮

# Pytest（State Machine 解析）
$ rtk pytest
# 追蹤測試狀態（IDLE → TEST_START → PASSED/FAILED → SUMMARY）
# 僅顯示失敗測試 → 90%+ 壓縮

# Pip（JSON 解析）
$ rtk pip list
# JSON 格式精簡表格 → 70-85% 壓縮
# 自動偵測 uv：若 uv 存在，自動使用 uv pip

# Go Test（NDJSON Streaming）
$ rtk go test ./...
# 逐行 JSON 解析，處理交錯的 package 事件
# → "2 packages, 3 failures (pkg1::TestAuth, ...)" → 75-90% 壓縮

# Go Build（Text Filtering）
$ rtk go build ./...
# 僅保留編譯器診斷訊息

# Go Vet（Text Filtering）
$ rtk go vet ./...
# 提取 file:line:message 三元組

# GolangCI-Lint（JSON 解析）
$ rtk golangci-lint run
# JSON API → 按 linter 規則分組 → 85% 壓縮

# Rake（State Machine，Minitest 輸出解析）
$ rtk rake test
# ok rake test: 8 runs, 0 failures → 85-90% 壓縮

# RSpec（JSON/Text 雙模式）
$ rtk rspec
# 自動注入 --format json → 60%+ 壓縮
# JSON 不可用時 fallback 至文字 state machine

# RuboCop（JSON 解析）
$ rtk rubocop
# 注入 --format json → 按 cop/severity 分組 → 60%+ 壓縮
# autocorrect 模式（-a, -A）跳過 JSON 注入

# Bundle Install（TOML Filter）
$ rtk bundle install
# 移除 "Using" 行，short-circuit 至 "ok bundle: complete" → 90%+ 壓縮

# dotnet build（Error Only）
$ rtk dotnet build
# 僅保留建置錯誤和警告 → 70-85% 壓縮

# dotnet test（Failure Focus）
$ rtk dotnet test
# 僅顯示失敗的測試 → 70-85% 壓縮

# binlog 分析
$ rtk dotnet binlog
# 結構化分析 MSBuild 二進位日誌

# Maven 建置
$ rtk mvn compile
# 移除下載進度、冗長的 BUILD 資訊

# Maven 測試
$ rtk mvn test
# Failure Focus → 僅顯示失敗的測試

# Gradle（v0.30+ 新增支援）
$ rtk gradle build
$ rtk gradlew test
# 支援 gradle 和 gradlew wrapper

┌──────────────────────────────────────────────────────┐
│              Token Savings by Ecosystem               │
├──────────────┬──────────┬───────────────────────────┤
│ Ecosystem    │ Savings  │ Commands                   │
├──────────────┼──────────┼───────────────────────────┤
│ GIT          │ 85-99%   │ status, diff, log, gh, gt │
│ JS/TS        │ 70-99%   │ lint, tsc, next, prettier │
│              │          │ playwright, prisma, vitest │
│              │          │ pnpm                       │
│ PYTHON       │ 70-90%   │ ruff, pytest, pip         │
│ GO           │ 75-90%   │ go test/build/vet         │
│              │          │ golangci-lint              │
│ RUBY         │ 60-90%   │ rake, rspec, rubocop      │
│ DOTNET       │ 70-85%   │ dotnet build/test, binlog │
│ RUST         │ 60-99%   │ cargo test/build/clippy   │
│ CLOUD        │ 60-80%   │ aws, docker, kubectl      │
│              │          │ curl, wget, psql           │
│ SYSTEM       │ 50-90%   │ ls, tree, read, grep      │
│              │          │ find, json, log, env, deps │
└──────────────┴──────────┴───────────────────────────┘

# AI Development Standard v1.0

## 1. 工具使用規範
- 所有 AI Coding Session 必須啟用 RTK
- 禁止在未啟用 RTK 的情況下進行大型 codebase 分析
- Token 消耗超過預算 80% 時必須通知 Tech Lead

## 2. RTK 設定規範
- 所有開發者必須使用 `rtk init -g` 設定全域 Hook
- 標準 config.toml 必須套用至所有開發環境
- CI/CD Pipeline 必須包含 RTK Token 報告

## 3. Prompt 規範
- 使用 RTK 精簡輸出作為 AI Context
- 大型檔案分析優先使用 `rtk read -l aggressive`
- 目錄結構使用 `rtk ls -u`

## 4. 安全規範
- 禁止將包含 secrets 的指令輸出傳送給 AI
- 使用 RTK 的 AWS 過濾器（自動移除 secrets）
- 日誌分析前必須確認無 PII

# team-rtk-config.toml
# 全團隊統一的 RTK 設定

[hooks]
# 排除不需要過濾的指令
exclude_commands = ["ssh", "scp", "rsync"]

[tee]
enabled = true
mode = "failures"

[tracking]
# 90 天資料保留
retention_days = 90

#!/bin/bash
# install-rtk-team.sh - 團隊標準安裝腳本

set -e

echo "=== RTK 團隊安裝腳本 ==="

# 1. 安裝 RTK
if ! command -v rtk &> /dev/null; then
    echo "安裝 RTK..."
    curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
    export PATH="$HOME/.local/bin:$PATH"
    echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
fi

# 2. 驗證安裝
rtk --version
rtk gain

# 3. 設定全域 Hook
rtk init -g --auto-patch

# 4. 套用團隊設定
mkdir -p ~/.config/rtk
curl -o ~/.config/rtk/config.toml https://internal.company.com/rtk/team-config.toml

# 5. 驗證
rtk init --show
echo "=== RTK 安裝完成 ==="

## 專案探索 Prompt
"Use rtk ls -u to show the project structure, then use rtk smart 
to summarize key files. Only use rtk read for files that need 
detailed analysis."

## Bug 修復 Prompt
"1. Use rtk git diff to see recent changes
 2. Use rtk test to identify failing tests
 3. Use rtk read on failing test files
 4. Fix the issue and verify with rtk test"

## Code Review Prompt
"1. Use rtk git log -5 to see recent commits
 2. Use rtk git diff main..feature-branch
 3. Use rtk lint to check code quality
 4. Use rtk tsc to verify type safety"

# 個人每日報告
rtk gain --daily

# 團隊報告（JSON 匯出）
rtk gain --all --format json > daily-report.json

# 發現優化機會
rtk discover --all --since 1

# Session 追蹤
rtk session

團隊：20 人
AI 工具：Claude Code（Claude 4 Sonnet API）
定價：$3 / 1M input tokens, $15 / 1M output tokens

未使用 RTK：
  每人每日 Token：50 萬（input）
  團隊每日 Token：1,000 萬
  每月成本：1,000 萬 × 30 × $3/M = $900 (input only)

使用 RTK 後（80% 節省）：
  每人每日 Token：10 萬（input）
  團隊每日 Token：200 萬
  每月成本：200 萬 × 30 × $3/M = $180
  
每月節省：$720
年度節省：$8,640

# 基本統計
rtk gain
# Commands: 1,234 | Avg savings: 78.5% | Total saved: 45,678 tokens

# 趨勢圖
rtk gain --graph
#  tokens │
#  saved  │     ╱╲
#         │   ╱    ╲    ╱╲
#         │ ╱        ╲╱    ╲
#         │╱                  ╲
#         └─────────────────────
#           Day 1         Day 30

# 每日明細
rtk gain --daily
# 2026-05-25: 234 commands, 12,345 tokens saved (82%)
# 2026-05-24: 198 commands, 10,234 tokens saved (79%)
# 2026-05-23: 267 commands, 15,678 tokens saved (85%)

# 歷史記錄
rtk gain --history
# Recent commands:
#   rtk git status    → 95% (300→15 tokens)
#   rtk cargo test    → 92% (5000→400 tokens)
#   rtk lint          → 88% (3000→360 tokens)

# JSON 匯出（自動化整合）
rtk gain --all --format json | jq .

#!/bin/bash
# generate-cost-report.sh

DATE=$(date +%Y-%m-%d)
REPORT_DIR="/shared/reports/rtk"
mkdir -p "$REPORT_DIR"

# 收集各開發者的 RTK 數據
rtk gain --all --format json > "$REPORT_DIR/$DATE-raw.json"

# 計算成本
cat "$REPORT_DIR/$DATE-raw.json" | jq '{
  date: "'$DATE'",
  total_commands: .total_commands,
  tokens_saved: .total_saved,
  estimated_cost_saved_usd: (.total_saved / 1000000 * 3),
  average_savings_pct: .avg_savings
}' > "$REPORT_DIR/$DATE-summary.json"

echo "Report generated: $REPORT_DIR/$DATE-summary.json"

# 資料收集（每日 cron job）
# crontab -e
0 18 * * * /path/to/generate-cost-report.sh

# 資料格式（JSON）
{
  "date": "2026-05-25",
  "team": "backend",
  "members": [
    {
      "name": "developer-1",
      "commands": 234,
      "tokens_saved": 45678,
      "savings_pct": 82.3,
      "top_commands": ["git status", "cargo test", "lint"]
    }
  ],
  "total_saved": 123456,
  "estimated_usd_saved": 0.37
}

# RTK 自動移除 Lambda 環境變數中的 secrets
rtk aws lambda list-functions
# my-function  python3.12  128MB
# 注意：環境變數已被過濾，不會出現在輸出中

# RTK 自動移除 IAM 角色的 policy documents
rtk aws iam list-roles
# role-name  arn:aws:iam::123:role/my-role  2024-01-01
# 注意：inline policies 已被移除

# 僅顯示匹配的環境變數（避免洩漏全部環境變數）
rtk env -f AWS
# AWS_REGION=us-east-1
# AWS_DEFAULT_REGION=us-east-1
# 注意：AWS_SECRET_ACCESS_KEY 等敏感值不會顯示

rtk env -f SPRING
# SPRING_PROFILES_ACTIVE=production
# SPRING_DATASOURCE_URL=jdbc:postgresql://db:5432/app

# ✅ 安全：使用 RTK 的 JSON 結構模式
rtk json user-data.json
# {users: [{id: string, name: string, email: string, ...}], count: number}
# 不會顯示實際值

# ✅ 安全：使用環境變數過濾
rtk env -f APP_
# 僅顯示 APP_ 開頭的變數

# ❌ 危險：直接 cat 包含敏感資料的檔案
cat secrets.json
# 所有內容會被送入 AI Context

# RTK 的日誌處理自動提供一定程度的淨化

# 1. Deduplication 減少重複的敏感日誌
rtk log /var/log/app/auth.log
# [INFO] Login attempt for user@company.com (×245)
# 而非 245 行各自包含用戶資訊

# 2. Docker 日誌去重複化
rtk docker logs auth-service
# 減少敏感資訊的曝露面

# 3. 環境變數安全過濾
rtk env -f DATABASE
# DATABASE_HOST=db.internal
# DATABASE_NAME=production
# 注意：DATABASE_PASSWORD 不會顯示（需要自行設定排除規則）

# 檢查遙測狀態
rtk telemetry status

# 啟用（需明確同意）
rtk telemetry enable

# 停用
rtk telemetry disable

# 停用 + 刪除所有本地資料 + 請求伺服器端刪除
rtk telemetry forget

# 環境變數強制停用
export RTK_TELEMETRY_DISABLED=1

# 檢查目前版本
rtk --version
# rtk 0.40.0

# 方法 1：Homebrew
brew update
brew upgrade rtk

# 方法 2：cargo install
cargo install --git https://github.com/rtk-ai/rtk

# 方法 3：install script（覆蓋安裝）
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# 方法 4：Windows winget
winget upgrade rtk-ai.rtk

# 方法 5：Nix
nix profile upgrade rtk

# 升級後驗證
rtk --version
rtk gain

# 備份設定檔
cp ~/.config/rtk/config.toml ~/.config/rtk/config.toml.bak

# 備份追蹤資料庫
cp ~/.local/share/rtk/history.db ~/.local/share/rtk/history.db.bak

# 備份 Hook 設定
cp ~/.claude/settings.json ~/.claude/settings.json.bak

# CI/CD 中指定版本安裝
RTK_VERSION="0.40.0"
cargo install --git https://github.com/rtk-ai/rtk --tag "v$RTK_VERSION"

# 或使用 GitHub Release
curl -L "https://github.com/rtk-ai/rtk/releases/download/v${RTK_VERSION}/rtk-${RTK_VERSION}-x86_64-linux.tar.gz" | tar xz

# === 備份 ===

# 設定檔
mkdir -p ~/rtk-backup/$(date +%Y%m%d)
cp ~/.config/rtk/config.toml ~/rtk-backup/$(date +%Y%m%d)/

# 追蹤資料庫
cp ~/.local/share/rtk/history.db ~/rtk-backup/$(date +%Y%m%d)/

# Hook 設定
cp ~/.claude/settings.json ~/rtk-backup/$(date +%Y%m%d)/

# 自動化備份（crontab）
# 0 0 * * 0 /path/to/backup-rtk.sh

# === 還原 ===

# 還原設定
cp ~/rtk-backup/20260525/config.toml ~/.config/rtk/config.toml

# 還原資料庫
cp ~/rtk-backup/20260525/history.db ~/.local/share/rtk/history.db

# 還原 Hook
cp ~/rtk-backup/20260525/settings.json ~/.claude/settings.json

# 1. 確認 RTK 可用
which rtk
rtk --version

# 2. 檢查 Hook 狀態
rtk init --show

# 3. 使用 verbose 模式
RTK_LOG=debug rtk ls src/

# 4. 比較原始 vs 精簡輸出
rtk tee ls src/
# 原始輸出儲存至檔案，精簡輸出顯示在終端

# 5. 檢查追蹤資料庫
rtk gain --history

# 6. 重設所有設定
rtk init -g --reset

# 每日監控腳本
#!/bin/bash
# rtk-daily-monitor.sh

echo "=== RTK Daily Monitor ==="
echo "Date: $(date)"
echo ""

# RTK 版本
echo "RTK Version: $(rtk --version)"

# 今日統計
echo ""
echo "=== Today's Stats ==="
rtk gain --daily

# 異常偵測（節省率低於 50%）
echo ""
echo "=== Low Savings Alerts ==="
rtk gain --all --format json | jq '
  .commands[] | select(.savings_pct < 50) |
  "\(.command): \(.savings_pct)% savings"
'

# 磁碟使用
echo ""
echo "=== Disk Usage ==="
du -sh ~/.local/share/rtk/

# 1. 大型輸出使用 aggressive 模式
rtk read large-file.ts -l aggressive    # 而非預設模式

# 2. 目錄瀏覽限制深度
rtk ls src/ -u                           # ultra-compact

# 3. 日誌分析限制行數
rtk docker logs app --tail 200           # 限制 200 行

# 4. 批次操作使用管線
find src/ -name "*.ts" | head -20 | xargs -I{} rtk read {} -l aggressive

// ~/.claude/settings.json
{
  "permissions": {
    "allow": [
      "Bash(rtk *)",
      "Bash(rtk ls *)",
      "Bash(rtk read *)",
      "Bash(rtk smart *)"
    ]
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "rtk hook pre-tool-use"
          }
        ]
      }
    ]
  }
}

# Shell Hook 整合（Bash）
# ~/.bashrc
eval "$(rtk hook shell bash)"

# Shell Hook 整合（Zsh）
# ~/.zshrc
eval "$(rtk hook shell zsh)"

# Shell Hook 整合（Fish）
# ~/.config/fish/config.fish
rtk hook shell fish | source

# PowerShell
# $PROFILE
Invoke-Expression (rtk hook shell pwsh)

---
description: RTK integration for token optimization
globs: ["**/*"]
alwaysApply: true
---

# RTK Workflow Rules

## File Reading
- Always use `rtk read <file> -l aggressive` instead of reading files directly
- Use `rtk ls -u` for directory exploration

## Testing
- Use `rtk test <command>` for all test executions
- Focus on failure output only

## Linting
- Use `rtk lint` for ESLint/Prettier checks
- Use `rtk tsc` for TypeScript checks

## Git
- Use `rtk git diff` for change analysis
- Use `rtk git status` for repository status

# Phase 1：Codebase 探索（30 分鐘）
rtk ls src/ -u
# src/ main/(450) test/(120) resources/(30)

rtk smart src/main/java/com/app/
# 控制器: 45, 服務: 38, 儲存庫: 25, 實體: 30, 設定: 15

rtk deps
# spring-boot: 2.7.18, spring-data: 2.7.18, hibernate: 5.6.15
# ⚠ 18 個過時依賴

# Phase 2：依賴分析（15 分鐘）
rtk read pom.xml -l aggressive
# 僅顯示 groupId, artifactId, version（壓縮 70%）

rtk grep "javax\." src/ --count
# javax.persistence: 156 occurrences
# javax.servlet: 23 occurrences
# javax.validation: 45 occurrences

# Phase 3：升級指引
rtk read CHANGELOG.md -l aggressive
# 逐版本重大變更摘要

# Phase 4：變更驗證（持續）
rtk test mvn test
# 120/120 tests passed ✓

rtk err mvn compile
# 0 errors ✓

# 探索 Monorepo 結構
rtk ls packages/ -u
# packages/ core/(45) ui/(60) hooks/(20) utils/(15) app/(80)

# 分析各套件的 JS/TS 比例
for pkg in core ui hooks utils app; do
    echo "=== $pkg ==="
    rtk ls packages/$pkg/src/ -u
done

# 類型錯誤分析
rtk tsc
# packages/core/src/Button.tsx: TS2345 (3 errors)
# packages/ui/src/Form.tsx: TS2322 (5 errors)
# Total: 8 errors in 2 files

# 遷移後驗證
rtk vitest
# packages/core: 45/45 passed ✓
# packages/ui: 60/60 passed ✓
# packages/hooks: 20/20 passed ✓
# Total: 125/125 passed ✓

# Lint 檢查
rtk lint
# 0 issues ✓

# 探索 COBOL 程式碼庫
rtk ls COBOL/ -u
# COBOL/ PROGRAMS/(150) COPYBOOKS/(80) JCL/(45) SCREENS/(30)

# 分析主要程式
rtk read COBOL/PROGRAMS/ACCT-PROCESS.cbl -l aggressive
# IDENTIFICATION DIVISION. PROGRAM-ID. ACCT-PROCESS.
# WORKING-STORAGE SECTION.
#   01 WS-ACCOUNT-RECORD.
#     05 WS-ACCT-NUM PIC 9(10).
#     ...
# PROCEDURE DIVISION.
#   PERFORM 1000-INIT
#   PERFORM 2000-PROCESS UNTIL WS-EOF
#   PERFORM 9000-CLEANUP

# 批次分析所有程式
find COBOL/PROGRAMS/ -name "*.cbl" | head -20 | \
    xargs -I{} rtk read {} -l aggressive > cobol-summary.txt

# COPYBOOK 分析（資料結構）
rtk read COBOL/COPYBOOKS/ACCT-RECORD.cpy
# 01 ACCT-RECORD.
#   05 ACCT-NUM PIC 9(10).
#   05 ACCT-NAME PIC X(30).
#   05 ACCT-BALANCE PIC S9(13)V99.

# JCL 流程分析
rtk read COBOL/JCL/DAILY-BATCH.jcl -l aggressive
# 僅顯示 EXEC 和 DD 關鍵步驟

# 整體架構分析
rtk ls src/ -u
# src/ controllers/(20) services/(15) repositories/(12) models/(18)

# 相依性分析
rtk grep "import.*service" src/services/ --count
# UserService → OrderService: 5 references
# OrderService → PaymentService: 3 references
# PaymentService → NotificationService: 2 references

# Docker Compose 狀態（拆分後）
rtk docker compose ps
# user-service       running  :3001
# order-service      running  :3002
# payment-service    running  :3003
# notification-svc   running  :3004
# api-gateway        running  :8080
# postgres           running  :5432
# redis              running  :6379
# rabbitmq           running  :5672

# 跨服務測試
rtk test docker compose exec user-service npm test
# 45/45 passed ✓

rtk test docker compose exec order-service npm test  
# 38/38 passed ✓

# 整合測試
rtk test npm run test:integration
# 20/20 passed ✓

# Cluster 狀態
rtk kubectl pods -A
# kube-system  coredns-abc123      Running  5d
# app          api-gateway-def456  Running  2h
# app          user-svc-ghi789     Running  2h
# app          order-svc-jkl012    Running  2h
# monitoring   prometheus-mno345   Running  5d
# monitoring   grafana-pqr678      Running  5d

# 服務健康度
rtk kubectl services -n app
# api-gateway    ClusterIP  10.0.0.1   80,443
# user-svc       ClusterIP  10.0.0.2   3001
# order-svc      ClusterIP  10.0.0.3   3002

# Pod 日誌（故障排除）
rtk kubectl logs api-gateway-def456
# [INFO] Request processed (×12,345)
# [WARN] Slow response from user-svc (×23)
# [ERROR] Connection refused: payment-svc (×5)

# Helm Release
rtk helm list -A
# app-stack    app         deployed  1.2.3  2h ago
# monitoring   monitoring  deployed  2.0.0  5d ago
# ingress      ingress     deployed  4.9.1  30d ago

# 資源使用
rtk kubectl top pods -n app
# api-gateway    150m/500m  256Mi/512Mi
# user-svc       80m/250m   128Mi/256Mi
# order-svc      120m/250m  192Mi/256Mi

╔══════════════════════════════════════════════════════════════════╗
║                    RTK Quick Reference                          ║
╠══════════════════════════════════════════════════════════════════╣
║                                                                  ║
║  安裝：                                                          ║
║    curl -fsSL .../install.sh | sh                                ║
║    brew install rtk                                              ║
║    cargo install --git https://github.com/rtk-ai/rtk             ║
║                                                                  ║
║  初始化：                                                        ║
║    rtk init -g                    全域 Hook（推薦）               ║
║    rtk init -g --auto-patch       自動修補（100% 攔截）           ║
║    rtk init --show                檢查 Hook 狀態                  ║
║                                                                  ║
║  檔案操作：                                                      ║
║    rtk ls <dir> -u                目錄結構（ultra-compact）       ║
║    rtk read <file>                讀取檔案（精簡）                ║
║    rtk read <file> -l aggressive  讀取檔案（高度壓縮）            ║
║    rtk smart <file|dir>           智慧摘要                        ║
║    rtk grep <pattern> <path>      精簡搜尋                        ║
║                                                                  ║
║  開發工具：                                                      ║
║    rtk test <cmd>                 測試（僅失敗）                  ║
║    rtk lint                       Linting（精簡）                 ║
║    rtk tsc                        TypeScript 檢查                 ║
║    rtk err <cmd>                  編譯錯誤                        ║
║    rtk deps                       依賴報告                        ║
║                                                                  ║
║  Git：                                                           ║
║    rtk git status                 精簡狀態                        ║
║    rtk git diff                   精簡差異                        ║
║    rtk git log -N                 精簡日誌                        ║
║                                                                  ║
║  容器/雲端：                                                     ║
║    rtk docker ps                  容器列表                        ║
║    rtk docker logs <name>         容器日誌（去重複）              ║
║    rtk kubectl pods               Pod 列表                        ║
║    rtk kubectl logs <pod>         Pod 日誌（去重複）              ║
║    rtk aws <service> <cmd>        AWS CLI（自動過濾 secrets）     ║
║                                                                  ║
║  分析：                                                          ║
║    rtk gain                       Token 節省報告                  ║
║    rtk gain --daily               每日報告                        ║
║    rtk gain --graph               趨勢圖                          ║
║    rtk discover                   發現未優化的指令                ║
║    rtk session                    Session 追蹤                    ║
║                                                                  ║
║  除錯：                                                          ║
║    rtk tee <cmd>                  同時保留原始+精簡輸出           ║
║    RTK_LOG=debug rtk <cmd>        Debug 模式                      ║
║                                                                  ║
╚══════════════════════════════════════════════════════════════════╝

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "rtk hook pre-tool-use"
          }
        ]
      }
    ]
  }
}

# ~/.bashrc
eval "$(rtk hook shell bash)"

# ~/.zshrc
eval "$(rtk hook shell zsh)"

# ~/.config/fish/config.fish
rtk hook shell fish | source

# $PROFILE
Invoke-Expression (rtk hook shell pwsh)

#!/bin/bash
# team-install-rtk.sh
set -euo pipefail

RTK_VERSION="${1:-latest}"
echo "=== Installing RTK $RTK_VERSION ==="

# 安裝
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
export PATH="$HOME/.local/bin:$PATH"

# 驗證
rtk --version

# 設定全域 Hook
rtk init -g --auto-patch

# 驗證 Hook
rtk init --show

echo "=== RTK Installation Complete ==="

#!/bin/bash
# daily-rtk-report.sh
DATE=$(date +%Y-%m-%d)
echo "RTK Daily Report - $DATE"
echo "========================"
rtk gain --daily
echo ""
echo "=== Optimization Opportunities ==="
rtk discover --all --since 1

// .vscode/settings.json
{
    // Terminal 設定 - 使用 RTK 友好的 Shell
    "terminal.integrated.defaultProfile.linux": "bash",
    "terminal.integrated.defaultProfile.osx": "zsh",
    "terminal.integrated.defaultProfile.windows": "PowerShell",
    
    // Terminal 環境變數
    "terminal.integrated.env.linux": {
        "PATH": "${env:HOME}/.local/bin:${env:PATH}"
    },
    "terminal.integrated.env.osx": {
        "PATH": "${env:HOME}/.local/bin:${env:PATH}"
    },
    
    // Copilot 設定
    "github.copilot.chat.terminalChatLocation": "terminal",
    
    // 排除 RTK 資料目錄
    "files.exclude": {
        "**/.rtk": true
    }
}

# RTK Configuration
# 位置：~/.config/rtk/config.toml

[hooks]
# 排除不適合過濾的指令
exclude_commands = [
    "ssh",
    "scp",
    "rsync",
    "vi",
    "vim",
    "nano",
    "code"
]

[tee]
# Tee Mode 設定
enabled = false
mode = "failures"   # "all" | "failures"
directory = "/tmp/rtk-tee"

[tracking]
# Token 追蹤設定
retention_days = 90

[telemetry]
# 遙測設定（企業建議停用）
enabled = false

# 確認 PATH
echo $PATH | tr ':' '\n' | grep -i rtk
# 或
echo $PATH | tr ':' '\n' | grep '.local/bin'

# 解決方案
export PATH="$HOME/.local/bin:$PATH"
# 永久生效：加入 ~/.bashrc 或 ~/.zshrc

# 檢查 Hook 狀態
rtk init --show

# 如果顯示 "not configured"
rtk init -g --auto-patch

# 重啟 AI 工具（Claude Code / VS Code）

# 使用 tee 模式比較
rtk tee <problematic-command>
# 檢查原始 vs 精簡輸出的差異

# 回報問題
# https://github.com/rtk-ai/rtk/issues

# 檢查指令覆蓋率
rtk discover

# 如果顯示許多未優化指令
# 確認全域 Hook 已啟用
rtk init --show

# 確認使用 auto-rewrite（而非 suggest）

# 確認 CI 環境中已安裝 RTK
which rtk || echo "RTK not installed"

# 確認 PATH 設定
export PATH="$HOME/.local/bin:$PATH"

# CI 中安裝
curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh

# 原因 1：未使用 RTK 指令
# 確認使用 "rtk <cmd>" 而非直接使用指令

# 原因 2：歷史資料已過期
# 預設保留 90 天

# 原因 3：新安裝
# 需要累積使用數據

# RTK 使用 per-user SQLite 資料庫
# 位置：~/.local/share/rtk/history.db
# 每個使用者獨立，無衝突

FROM node:20
RUN curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh
ENV PATH="/root/.local/bin:${PATH}"
RUN rtk --version

# 是，RTK 支援 Windows 原生
# 安裝方式：
winget install rtk-ai.rtk
# 或 cargo install
cargo install --git https://github.com/rtk-ai/rtk

# 設定 PowerShell Hook
Invoke-Expression (rtk hook shell pwsh)

# RTK 不會影響原始工具的行為
# RTK 僅在被明確呼叫時（rtk <cmd>）或 Hook 啟用時運作
# Exit code 完全保留
# 如有衝突，可在 config.toml 中排除特定指令