# RTK Compression (മലയാളം)

🌐 **Languages:** 🇺🇸 [English](../../../../compression/RTK_COMPRESSION.md) · 🇪🇹 [am](../../../am/docs/compression/RTK_COMPRESSION.md) · 🇸🇦 [ar](../../../ar/docs/compression/RTK_COMPRESSION.md) · 🇦🇿 [az](../../../az/docs/compression/RTK_COMPRESSION.md) · 🇧🇬 [bg](../../../bg/docs/compression/RTK_COMPRESSION.md) · 🇧🇩 [bn](../../../bn/docs/compression/RTK_COMPRESSION.md) · 🇧🇦 [bs](../../../bs/docs/compression/RTK_COMPRESSION.md) · 🇨🇿 [cs](../../../cs/docs/compression/RTK_COMPRESSION.md) · 🇩🇰 [da](../../../da/docs/compression/RTK_COMPRESSION.md) · 🇩🇪 [de](../../../de/docs/compression/RTK_COMPRESSION.md) · 🇬🇷 [el](../../../el/docs/compression/RTK_COMPRESSION.md) · 🇪🇸 [es](../../../es/docs/compression/RTK_COMPRESSION.md) · 🇪🇪 [et](../../../et/docs/compression/RTK_COMPRESSION.md) · 🇮🇷 [fa](../../../fa/docs/compression/RTK_COMPRESSION.md) · 🇫🇮 [fi](../../../fi/docs/compression/RTK_COMPRESSION.md) · 🇫🇷 [fr](../../../fr/docs/compression/RTK_COMPRESSION.md) · 🇮🇪 [ga](../../../ga/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [gu](../../../gu/docs/compression/RTK_COMPRESSION.md) · 🇳🇬 [ha](../../../ha/docs/compression/RTK_COMPRESSION.md) · 🇮🇱 [he](../../../he/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [hi](../../../hi/docs/compression/RTK_COMPRESSION.md) · 🇭🇷 [hr](../../../hr/docs/compression/RTK_COMPRESSION.md) · 🇭🇺 [hu](../../../hu/docs/compression/RTK_COMPRESSION.md) · 🇦🇲 [hy](../../../hy/docs/compression/RTK_COMPRESSION.md) · 🇮🇩 [id](../../../id/docs/compression/RTK_COMPRESSION.md) · 🇳🇬 [ig](../../../ig/docs/compression/RTK_COMPRESSION.md) · 🇮🇹 [it](../../../it/docs/compression/RTK_COMPRESSION.md) · 🇯🇵 [ja](../../../ja/docs/compression/RTK_COMPRESSION.md) · 🇬🇪 [ka](../../../ka/docs/compression/RTK_COMPRESSION.md) · 🇰🇭 [km](../../../km/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [kn](../../../kn/docs/compression/RTK_COMPRESSION.md) · 🇰🇷 [ko](../../../ko/docs/compression/RTK_COMPRESSION.md) · 🇱🇹 [lt](../../../lt/docs/compression/RTK_COMPRESSION.md) · 🇱🇻 [lv](../../../lv/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [mr](../../../mr/docs/compression/RTK_COMPRESSION.md) · 🇲🇾 [ms](../../../ms/docs/compression/RTK_COMPRESSION.md) · 🇲🇹 [mt](../../../mt/docs/compression/RTK_COMPRESSION.md) · 🇲🇲 [my](../../../my/docs/compression/RTK_COMPRESSION.md) · 🇳🇵 [ne](../../../ne/docs/compression/RTK_COMPRESSION.md) · 🇳🇱 [nl](../../../nl/docs/compression/RTK_COMPRESSION.md) · 🇳🇴 [no](../../../no/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [or](../../../or/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [pa](../../../pa/docs/compression/RTK_COMPRESSION.md) · 🇵🇭 [phi](../../../phi/docs/compression/RTK_COMPRESSION.md) · 🇵🇱 [pl](../../../pl/docs/compression/RTK_COMPRESSION.md) · 🇵🇹 [pt](../../../pt/docs/compression/RTK_COMPRESSION.md) · 🇧🇷 [pt-BR](../../../pt-BR/docs/compression/RTK_COMPRESSION.md) · 🇷🇴 [ro](../../../ro/docs/compression/RTK_COMPRESSION.md) · 🇷🇺 [ru](../../../ru/docs/compression/RTK_COMPRESSION.md) · 🇱🇰 [si](../../../si/docs/compression/RTK_COMPRESSION.md) · 🇸🇰 [sk](../../../sk/docs/compression/RTK_COMPRESSION.md) · 🇸🇮 [sl](../../../sl/docs/compression/RTK_COMPRESSION.md) · 🇷🇸 [sr](../../../sr/docs/compression/RTK_COMPRESSION.md) · 🇸🇪 [sv](../../../sv/docs/compression/RTK_COMPRESSION.md) · 🇰🇪 [sw](../../../sw/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [ta](../../../ta/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [te](../../../te/docs/compression/RTK_COMPRESSION.md) · 🇹🇭 [th](../../../th/docs/compression/RTK_COMPRESSION.md) · 🇹🇷 [tr](../../../tr/docs/compression/RTK_COMPRESSION.md) · 🇺🇦 [uk-UA](../../../uk-UA/docs/compression/RTK_COMPRESSION.md) · 🇵🇰 [ur](../../../ur/docs/compression/RTK_COMPRESSION.md) · 🇺🇿 [uz](../../../uz/docs/compression/RTK_COMPRESSION.md) · 🇻🇳 [vi](../../../vi/docs/compression/RTK_COMPRESSION.md) · 🇳🇬 [yo](../../../yo/docs/compression/RTK_COMPRESSION.md) · 🇨🇳 [zh-CN](../../../zh-CN/docs/compression/RTK_COMPRESSION.md) · 🇹🇼 [zh-TW](../../../zh-TW/docs/compression/RTK_COMPRESSION.md)

---

RTK കംപ്രഷൻ എന്നത് ടെർമിനൽ, ടൂൾ ഔട്ട്പുട്ടുകൾക്കായുള്ള OmniRoute-ന്റെ കമാൻഡ്-അവബോധമുള്ള കംപ്രഷൻ എഞ്ചിനാണ്. ടെസ്റ്റ് ലോഗുകൾ, ബിൽഡ് ഔട്ട്പുട്ട്, പാക്കേജ് മാനേജർ അനാവശ്യ ഔട്ട്പുട്ട്, ഷെൽ ട്രാൻസ്ക്രിപ്റ്റുകൾ, Docker ഔട്ട്പുട്ട്, git ഔട്ട്പുട്ട്, സ്റ്റാക്ക് ട്രേസുകൾ എന്നിവയിൽ നിന്നാണ് സന്ദർഭത്തിന്റെ ഭൂരിഭാഗം വളർച്ചയും ഉണ്ടാകുന്നത് എന്ന തരത്തിലുള്ള കോഡിംഗ്-ഏജന്റ് സെഷനുകൾക്കായാണ് ഇത് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.

RTK-യെ `defaultMode: "rtk"` ഉപയോഗിച്ച് നേരിട്ടോ, സാധാരണയായി താഴെ കാണുന്നതുപോലെ ഒരു സ്റ്റാക്ക്ഡ് പൈപ്പ്ലൈനിലെ ആദ്യ ഘട്ടമായോ പ്രവർത്തിപ്പിക്കാം:

```txt
rtk -> caveman
```

ഈ ക്രമം ആദ്യം അനാവശ്യമായ മെഷീൻ ഔട്ട്പുട്ട് കംപ്രസ് ചെയ്യുകയും തുടർന്ന് ശേഷിക്കുന്ന ഗദ്യത്തെ സംക്ഷിപ്തമാക്കാൻ Caveman-നെ അനുവദിക്കുകയും ചെയ്യുന്നു.

അപ്സ്ട്രീം RTK കമാൻഡ് ഔട്ട്പുട്ടിൽ `60-90%` ലാഭം റിപ്പോർട്ട് ചെയ്യുന്നു. അതിന്റെ README-യിലെ മാതൃകാ സെഷൻ
`~118,000` സ്റ്റാൻഡേർഡ് ടോക്കണുകളിൽ നിന്ന് `~23,900` RTK ടോക്കണുകളിലേക്ക് കുറയുന്നു; ഇത് `79.7%` ലാഭമാണ് (`~80%`). Caveman ഇൻപുട്ട് കംപ്രഷനുമായി ചേർത്തുള്ള സ്റ്റാക്ക്ഡ് ലാഭം കണക്കാക്കാൻ OmniRoute ആ അപ്സ്ട്രീം ശരാശരി ഉപയോഗിക്കുന്നു:

```txt
RTK ശരാശരി:     80% ലാഭം
Caveman ഇൻപുട്ട്: 46% ലാഭം
സ്റ്റാക്ക്ഡ്:       1 - (1 - 0.80) * (1 - 0.46) = 89.2% ലാഭം
പരിധി:           1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%
```

## ഇത് കംപ്രസ് ചെയ്യുന്നവ

ബിൽറ്റ്-ഇൻ കാറ്റലോഗിൽ നിലവിൽ ഈ വിഭാഗങ്ങളിലായി 49 ഫിൽട്ടറുകൾ ഉൾപ്പെടുത്തിയിരിക്കുന്നു:

| വിഭാഗം    | ഉദാഹരണങ്ങൾ                                                           |
| --------- | -------------------------------------------------------------------- |
| `git`     | `git status`, `git branch`, `git diff`, `git log`                    |
| `test`    | Vitest, Jest, Pytest, Playwright, Go ടെസ്റ്റുകൾ, Cargo ടെസ്റ്റുകൾ    |
| `build`   | TypeScript, ESLint, Biome, Prettier, Vite, Webpack, Turbo, Nx        |
| `package` | `npm install`, `npm audit`, `pip`, `uv sync`, Poetry, Bundler        |
| `shell`   | `ls`, `find`, `grep`, പൊതുവായ ഷെൽ ലോഗുകൾ                             |
| `docker`  | `docker ps`, Docker ലോഗുകൾ                                           |
| `infra`   | Terraform, OpenTofu, `systemctl status`                              |
| `generic` | JSON ഔട്ട്പുട്ട്, സ്റ്റാക്ക് ട്രേസുകൾ, പൊതുവായ ഔട്ട്പുട്ട് ഫാൾബാക്ക് |

`open-sse/services/compression/engines/rtk/commandDetector.ts`-ലെ ഡിറ്റക്ടർ ഫിൽട്ടർ തിരഞ്ഞെടുക്കുന്നതിന് മുമ്പ് ഔട്ട്പുട്ടിനെ വർഗ്ഗീകരിക്കുന്നു. ഒരു കമാൻഡ് ക്ലാസ് മാത്രം മതിയാകാത്തപ്പോൾ, കമാൻഡ് പാറ്റേൺ അല്ലെങ്കിൽ ഔട്ട്പുട്ട് regex ഉപയോഗിച്ചും ഫിൽട്ടറുകൾക്ക് പൊരുത്തപ്പെടാനാകും.

## ഫിൽട്ടർ റെസല്യൂഷൻ

RTK താഴെപ്പറയുന്ന ക്രമത്തിൽ ഫിൽട്ടറുകൾ ലോഡ് ചെയ്യുന്നു:

1. വിശ്വസനീയമാണെങ്കിൽ മാത്രം `.rtk/filters.toml`, `.rtk/filters.json` എന്നിവയിൽ നിന്നുള്ള പ്രോജക്റ്റ് ഫിൽട്ടറുകൾ.
2. `DATA_DIR/rtk/filters.toml`, `DATA_DIR/rtk/filters.json` എന്നിവയിൽ നിന്നുള്ള ഗ്ലോബൽ ഫിൽട്ടറുകൾ.
3. `open-sse/services/compression/engines/rtk/filters/`-ൽ നിന്നുള്ള ബിൽറ്റ്-ഇൻ ഫിൽട്ടറുകൾ.

ഒരേ സ്കോപ്പിനുള്ളിൽ, RTK TOML schema v1 ഫിൽട്ടറുകൾക്ക് OmniRoute JSON ഫിൽട്ടറുകളേക്കാൾ മുൻഗണന ലഭിക്കുന്നു. ഇറക്കുമതി ചെയ്ത കമാൻഡ്-നിർദ്ദിഷ്ട ഫിൽട്ടറിന് ആ സ്കോപ്പിലെ കൂടുതൽ വിപുലമായ ഫിൽട്ടറിനെ മറികടക്കാൻ കഴിയുന്നവിധം, കമാൻഡ്-ടൈപ്പ് മാച്ചിങ്ങിന് മുമ്പ് TOML `match_command` എക്സ്പ്രഷനുകൾ പരിശോധിക്കുന്നു. ഫയൽ ഫോർമാറ്റ് പരിഗണിക്കാതെ തന്നെ, പ്രോജക്റ്റ് സ്കോപ്പിന് ഗ്ലോബൽ സ്കോപ്പിനേക്കാൾ മുൻഗണന തുടരും.

regex ഫിൽട്ടറുകൾക്ക് ടൂൾ ഔട്ട്പുട്ട് ഏജന്റുകൾക്ക് കാണിക്കുന്ന രീതി മാറ്റാൻ കഴിയുന്നതിനാൽ, പ്രോജക്റ്റ് ഫിൽട്ടറുകൾ ബോധപൂർവം ട്രസ്റ്റ്-ഗേറ്റഡ് ആക്കിയിരിക്കുന്നു. താഴെപ്പറയുന്നവയിൽ ഒന്ന് ശരിയായിരിക്കുമ്പോൾ ഒരു പ്രോജക്റ്റ് ഫിൽട്ടർ ഫയൽ സ്വീകരിക്കപ്പെടും:

- `rtkConfig.trustProjectFilters` എന്നത് `true` ആണ്.
- `OMNIROUTE_RTK_TRUST_PROJECT_FILTERS=1` സജ്ജീകരിച്ചിരിക്കുന്നു.
- പ്രോജക്റ്റ് ഫിൽട്ടർ ഫയലുമായി പൊരുത്തപ്പെടുന്ന SHA-256 ഹാഷ് `.rtk/trust.json`-ൽ അടങ്ങിയിരിക്കുന്നു.

ട്രസ്റ്റ് ഫയലിന്റെ ഉദാഹരണം:

```json
{
  "filtersSha256": "0123456789abcdef...",
  "filtersTomlSha256": "fedcba9876543210..."
}
```

ഹാഷുകൾ വേർതിരിച്ചാണ് സൂക്ഷിക്കുന്നത്: `filtersSha256` `.rtk/filters.json`-നെ വിശ്വസനീയമാക്കുന്നു, അതേസമയം `filtersTomlSha256` `.rtk/filters.toml`-നെ വിശ്വസനീയമാക്കുന്നു. ഏതെങ്കിലും ഫയൽ എഡിറ്റ് ചെയ്യുന്നത് അതിന്റെ സ്വന്തം ട്രസ്റ്റ് എൻട്രിയെ മാത്രമാണ് അസാധുവാക്കുന്നത്. ഗ്ലോബൽ ഫയലുകൾ അഡ്മിനിസ്ട്രേറ്റർ ഇൻസ്റ്റാൾ ചെയ്തവയാണ്, അവ നിലവിലുള്ള ഗ്ലോബൽ-ഫിൽട്ടർ ട്രസ്റ്റ് സ്വഭാവം ഉപയോഗിക്കുന്നു.

കസ്റ്റം ഫിൽട്ടറുകൾ ഒരു ഫിൽട്ടർ ഒബ്ജക്റ്റോ ഫിൽട്ടർ ഒബ്ജക്റ്റുകളുടെ ഒരു അറേയോ ആകാം. അസാധുവായ കസ്റ്റം ഫിൽട്ടറുകൾ ഒഴിവാക്കുകയും `/api/context/rtk/filters` ഡയഗ്നോസ്റ്റിക്സ് വഴി റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യും. അസാധുവായ ബിൽറ്റ്-ഇൻ ഫിൽട്ടറുകൾ ഉടൻ പരാജയപ്പെടും.

## RTK TOML സ്കീമ v1 അനുയോജ്യത

RTK TOML സ്കീമ v1 ഉപയോഗിക്കുന്ന പ്രഖ്യാപനാത്മക ഫിൽട്ടർ ഫയലുകൾ OmniRoute-ന് പാർസ് ചെയ്യാനും സാധുത പരിശോധിക്കാനും പരീക്ഷിക്കാനും ഇൻസ്റ്റാൾ ചെയ്യാനും കഴിയും.
പിന്തുണയ്ക്കുന്ന ഫീൽഡുകൾ `description`, `match_command`, `strip_ansi`, `filter_stderr`,
`strip_lines_matching`, `keep_lines_matching`, `replace`, `match_output`, `truncate_lines_at`,
`head_lines`, `tail_lines`, `max_lines`, `on_empty`, കൂടാതെ `[[tests.<filter>]]` ഇൻലൈൻ ടെസ്റ്റുകൾ എന്നിവയാണ്.
അജ്ഞാത ഫീൽഡുകൾ, അസാധുവോ സുരക്ഷിതമല്ലാത്തതോ ആയ റെഗുലർ എക്സ്പ്രഷനുകൾ, ഒരേസമയം നൽകിയിരിക്കുന്ന strip/keep നിയമങ്ങൾ, 1 MiB-യിൽ കൂടുതലുള്ള ഫയലുകൾ,
അജ്ഞാത ഫിൽട്ടറുകളിലേക്കുള്ള റഫറൻസുകൾ എന്നിവ നിരസിക്കപ്പെടും. ഇൻലൈൻ ടെസ്റ്റുകൾ പരാജയപ്പെടുന്ന ഒരു ഫയൽ
പരിശോധനയ്ക്കായി സാധൂകരിക്കാമെങ്കിലും ഇൻസ്റ്റാൾ ചെയ്യാനോ ലോഡ് ചെയ്യാനോ കഴിയില്ല. ഇഷ്ടാനുസൃത ഫയൽ ലോഡ് ചെയ്യുന്നതിലെ പരാജയങ്ങൾ
fail-open ആയി തുടരും: അസാധുവായ ഫയൽ ഒഴിവാക്കുകയും ശേഷിക്കുന്ന ഫിൽട്ടറുകൾ തുടർന്നും പ്രവർത്തിക്കുകയും ചെയ്യും.

ക്ലയന്റ് ടൂൾ ഔട്ട്പുട്ട് ഇതിനകം ക്യാപ്ചർ ചെയ്തതിനുശേഷമാണ് OmniRoute-ന് അത് ലഭിക്കുന്നത്, അതിനാൽ `filter_stderr = true`
എന്നത് പ്രോസസ് ക്യാപ്ചർ മാറ്റാൻ കഴിയില്ല. ഈ ഫീൽഡ് ഒരു no-op ആയി സ്വീകരിക്കുകയും സാധുതാ പരിശോധന ഒരു മുന്നറിയിപ്പ് നൽകുകയും ചെയ്യും.
ഇത് മനഃപൂർവം **RTK TOML സ്കീമ v1 അനുയോജ്യത** എന്നാണ് വിവരിച്ചിരിക്കുന്നത്; RTK എക്സിക്യൂട്ടബിൾ,
ഷെൽ ഹുക്കുകൾ, Rust കമാൻഡ് ഇംപ്ലിമെന്റേഷനുകൾ, അല്ലെങ്കിൽ അതിന്റെ trust-store ലേഔട്ട് എന്നിവയുമായുള്ള പൂർണ്ണ അനുയോജ്യത എന്നല്ല.

ഡാഷ്ബോർഡിന്റെ വിപുലമായ RTK വ്യൂ, പേസ്റ്റ് ചെയ്തതോ അപ്ലോഡ് ചെയ്തതോ ആയ TOML സ്വീകരിക്കുന്നു. സാധുതാ പരിശോധന വായനയ്ക്ക് മാത്രമുള്ളതാണ്.
ഇൻസ്റ്റാളേഷൻ നിയന്ത്രിത അനുമതികളോടെ `DATA_DIR/rtk/filters.toml` ആറ്റോമിക്കായി എഴുതുകയും
പുനരാരംഭിക്കാതെ തന്നെ ലൈവ് ഫിൽട്ടർ കാറ്റലോഗ് പുതുക്കുകയും ചെയ്യുന്നു. നിലവിലുള്ള ഫയൽ മാറ്റിസ്ഥാപിക്കുന്നതിന് വ്യക്തമായ `overwrite`
സ്ഥിരീകരണം ആവശ്യമാണ്; ആദ്യം `DATA_DIR/rtk/filters.toml.bak` സൃഷ്ടിക്കുകയും ചെയ്യും.

## ഫിൽട്ടർ DSL

ഫിൽട്ടറുകൾ [Compression Rules Format](./COMPRESSION_RULES_FORMAT.md)-ൽ വിവരിച്ചിരിക്കുന്ന JSON സ്കീമ ഉപയോഗിക്കുന്നു.
റൺടൈം ഈ ഘട്ടങ്ങൾ ക്രമത്തിൽ പ്രയോഗിക്കുന്നു:

```txt
stripAnsi -> filterStderr -> replace -> matchOutput -> drop/include lines
  -> truncateLineAt -> head/tail/maxLines -> onEmpty
```

പ്രധാനപ്പെട്ട ഫീൽഡുകൾ:

| ഫീൽഡ്                        | ഉദ്ദേശ്യം                                                                                     |
| ---------------------------- | --------------------------------------------------------------------------------------------- |
| `rules.stripAnsi`            | മാച്ച് ചെയ്യുന്നതിന് മുമ്പ് ടെർമിനൽ നിറ/നിയന്ത്രണ സീക്വൻസുകൾ നീക്കംചെയ്യുക                    |
| `rules.filterStderr`         | മാച്ച് ചെയ്യുന്നതിനോ ഫിൽട്ടർ ചെയ്യുന്നതിനോ മുമ്പ് സാധാരണ stderr പ്രിഫിക്സുകൾ നോർമലൈസ് ചെയ്യുക |
| `rules.replace`              | ക്രമപ്പെടുത്തിയ റെഗുലർ എക്സ്പ്രഷൻ മാറ്റിസ്ഥാപിക്കലുകൾ പ്രയോഗിക്കുക                            |
| `rules.matchOutput`          | ഔട്ട്പുട്ട് അറിയപ്പെടുന്ന ഒരു അവസ്ഥയുമായി പൊരുത്തപ്പെടുമ്പോൾ സംക്ഷിപ്ത സംഗ്രഹം നൽകുക          |
| `rules.matchOutput[].unless` | ഒരു പിശക്/പരാജയ പാറ്റേൺ നിലവിലുണ്ടെങ്കിൽ കുറുക്കുവഴി ഒഴിവാക്കുക                               |
| `rules.dropPatterns`         | അനാവശ്യ ശബ്ദമുള്ള വരികൾ നീക്കംചെയ്യുക                                                         |
| `rules.includePatterns`      | നടപടിയെടുക്കാവുന്ന വരികൾക്ക് മുൻഗണന നൽകുക                                                     |
| `rules.collapsePatterns`     | ആവർത്തിച്ചുവരുന്ന പൊരുത്തമുള്ള വരികൾ ചുരുക്കുക                                                |
| `rules.deduplicate`          | ഓരോ ഫിൽട്ടറിനുമുള്ള opt-in: തുടർച്ചയായ തനിപ്പകർപ്പ് വരികൾ ചുരുക്കുക                           |
| `rules.truncateLineAt`       | Unicode-സുരക്ഷിതമായ ഓരോ വരിയുടെയും ചുരുക്കൽ                                                   |
| `rules.onEmpty`              | എല്ലാ വരികളും ഫിൽട്ടർ ചെയ്യപ്പെട്ടാൽ ഉപയോഗിക്കേണ്ട പകരം സന്ദേശം                               |
| `tests[]`                    | verify gate ഉപയോഗിക്കുന്ന ഇൻലൈൻ സാമ്പിളുകൾ                                                    |

ബിൽറ്റ്-ഇൻ ഫിൽട്ടറുകളിൽ ഇൻലൈൻ `tests[]` സാമ്പിളുകൾ ഉൾപ്പെടുമെന്ന് പ്രതീക്ഷിക്കുന്നു. ഇഷ്ടാനുസൃത ഫിൽട്ടറുകളിലും
അവ ഉൾപ്പെടുത്തണം, പ്രത്യേകിച്ചും അവ പ്രോജക്റ്റുകൾക്കിടയിൽ പങ്കിടുമ്പോൾ.

## വരി ഡീഡ്യൂപ്ലിക്കേഷൻ (രണ്ട് തലങ്ങൾ)

RTK രണ്ട് സ്വതന്ത്ര തലങ്ങളിൽ ആവർത്തിക്കുന്ന വരികളെ സംയോജിപ്പിക്കുന്നു:

1. **ഓരോ ഫിൽട്ടറിനുമുള്ള `deduplicate` (ഓപ്റ്റ്-ഇൻ, ഡിഫോൾട്ട് `false`).** ഒരു ഫിൽട്ടറിന് `rules.deduplicate: true`
   ആയി സജ്ജീകരിച്ച്, വെട്ടിച്ചുരുക്കുന്നതിന് മുമ്പ് _ആ ഫിൽട്ടറുമായി പൊരുത്തപ്പെട്ട ഔട്ട്പുട്ടിനുള്ളിലെ_ തുടർച്ചയായ ആവർത്തന വരികളെ
   സംയോജിപ്പിക്കാം. ഇത് `lineFilter.ts`-നുള്ളിലാണ് പ്രവർത്തിക്കുന്നത്. ലെഗസി ഫിൽട്ടറുകൾക്ക്, ഫിൽട്ടർ
   `collapsePatterns` നിർവചിക്കുമ്പോൾ ഇത് സ്വയമേവ പ്രവർത്തനക്ഷമമാക്കപ്പെടും. സ്കീമ:
   `open-sse/services/compression/engines/rtk/filterSchema.ts`-ൽ `deduplicate: z.boolean().default(false)`.
2. **എൻജിൻ-വ്യാപകമായ `deduplicateThreshold` (ഡിഫോൾട്ട് `3`).** എല്ലാ ഫിൽട്ടറുകളും പ്രവർത്തിച്ചതിന് ശേഷം, മുഴുവൻ ഫലത്തിലുമുള്ള
   ഒരേപോലെയുള്ള തുടർച്ചയായ വരികളുടെ `>= deduplicateThreshold` ദൈർഘ്യമുള്ള ഏത് നിരയെയും എൻജിൻ സംയോജിപ്പിക്കുന്നു
   (`deduplicateRepeatedLines`, `engines/rtk/index.ts`-ൽ പ്രയോഗിക്കുന്നു). നോർമലൈസേഷൻ സമയത്ത് മൂല്യം 2–100 പരിധിയിൽ
   പരിമിതപ്പെടുത്തുന്നു.

ഓരോ ഫിൽട്ടറിനുമുള്ള പാസ് ആദ്യം പ്രവർത്തിക്കുന്നു (ഫിൽട്ടറിനുള്ളിൽ), എൻജിൻ-വ്യാപകമായ പാസ് അവസാനം പ്രവർത്തിക്കുന്നു (കൂട്ടിച്ചേർത്ത
ഔട്ട്പുട്ടിന്മേൽ), അതിനാൽ രണ്ടുതവണ എണ്ണാതെ ഇവ രണ്ടും സംയോജിച്ച് പ്രവർത്തിക്കുന്നു.

## വരി ഗ്രൂപ്പിംഗ് (`enableGrouping`)

`rtkConfig.enableGrouping` `true` ആയിരിക്കുമ്പോൾ (ഡിഫോൾട്ട് `false`), ഡീഡ്യൂപ്ലിക്കേഷനുശേഷമുള്ള ഫലത്തിന്മേൽ RTK ഒരു അധിക
`groupSimilarLines` പാസ് പ്രവർത്തിപ്പിക്കുന്നു; ഇത് _ഏതാണ്ട് തുല്യമായ_ (ബൈറ്റ് തലത്തിൽ സമാനമല്ലാത്ത)
തുടർച്ചയായ വരികളുടെ നിരകളെ സംയോജിപ്പിക്കുന്നു. ഗ്രൂപ്പിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്ന ഏറ്റവും കുറഞ്ഞ നിര ദൈർഘ്യമാണ്
`rtkConfig.groupingThreshold` (ഡിഫോൾട്ട് `3`). ഇത് `deduplicateThreshold`-ന്റെ ഘടനാപരമായ സമാനഘടകമാണ്: ഡീഡ്യൂപ്ലിക്കേഷൻ
കൃത്യമായ ആവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുമ്പോൾ, ഗ്രൂപ്പിംഗ് "ചെറിയ വ്യത്യാസങ്ങളുള്ള ഒരേ ഘടന" കൈകാര്യം ചെയ്യുന്നു. രണ്ട് ഫ്ലാഗുകളും
`key_value` പട്ടികയിൽ നിലനിർത്തുന്ന `rtkConfig` JSON-ന്റെ ഭാഗമാണ് (മുകളിലെ കോൺഫിഗറേഷൻ കാണുക), അതിനാൽ പുനരാരംഭങ്ങൾക്കുശേഷവും
ക്രമീകരണം നിലനിൽക്കും.

## കോഡ് കമന്റ് നീക്കംചെയ്യൽ (`stripCodeComments` / `preserveDocstrings`)

`rtkConfig.applyToCodeBlocks` പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുമ്പോൾ, ഫെൻസ് ചെയ്ത കോഡ് ബ്ലോക്കുകളിൽനിന്ന് കമന്റുകളും RTK-ക്ക് നീക്കംചെയ്യാനാകും:

- `stripCodeComments` (ഡിഫോൾട്ട് `false`) — ഓപ്റ്റ്-ഇൻ. `true` ആയിരിക്കുമ്പോൾ, JavaScript, TypeScript
  ഫെൻസ് ചെയ്ത ബ്ലോക്കുകളിൽനിന്ന് RTK കമന്റുകൾ നീക്കംചെയ്യുന്നു. ചരിത്രപരമായി ഈ ഫ്ലാഗ് വായിച്ചിരുന്നെങ്കിലും ഒരിക്കലും പ്രയോഗിച്ചിരുന്നില്ല,
  അതിനാൽ പ്രൊഡക്ഷനിൽ അറിയിപ്പില്ലാത്ത മാറ്റം ഒഴിവാക്കാൻ ഡിഫോൾട്ട് "നിലനിർത്തുക" എന്നതായിത്തന്നെ തുടരുന്നു.
- `preserveDocstrings` (ഡിഫോൾട്ട് `true`) — കമന്റുകൾ നീക്കംചെയ്യുമ്പോൾ, JSDoc/`/** … */` ബ്ലോക്ക് കമന്റുകൾ
  നിലനിർത്തുന്നു (അവയുടെ ബൈറ്റ് ചെലവിനേക്കാൾ വിലമതിക്കുന്ന API ഡോക്യുമെന്റേഷൻ അവയിൽ അടങ്ങിയിരിക്കുന്നു). അവയും നീക്കംചെയ്യാൻ
  ഇത് `false` ആയി സജ്ജീകരിക്കുക.

കമന്റ് നീക്കംചെയ്യൽ `open-sse/services/compression/engines/rtk/codeStripper.ts`-ൽ നടപ്പാക്കിയിരിക്കുന്നു. സ്ട്രിംഗ്, ടെംപ്ലേറ്റ്,
റെഗെക്സ് ലിറ്ററലുകൾ ഒരിക്കലും കമന്റുകളായി തെറ്റിദ്ധരിക്കപ്പെടാതിരിക്കാൻ ഇത് **TypeScript parser** ആണ് ഉപയോഗിക്കുന്നത് (regex അല്ല);
കൂടാതെ JSX കണ്ടെത്തുമ്പോൾ ഇത് പൂർണ്ണമായും പ്രവർത്തനം നിർത്തുന്നു (അതിനാൽ JSX എക്സ്പ്രഷൻ-കണ്ടെയ്നർ കമന്റുകൾ ഒരിക്കലും
കേടാകില്ല). നിലവിൽ കമന്റ് നീക്കംചെയ്യൽ **JavaScript, TypeScript എന്നിവയ്ക്ക് മാത്രം** ബാധകമാണ് — സ്ട്രിപ്പറിന്റെ
`CodeLanguage` സെറ്റിലെ മറ്റ് ഭാഷകൾക്ക് (Python, Rust, Go, Ruby, Java) ശൂന്യവരി, വൈറ്റ്സ്പേസ് സംയോജനം ഉണ്ടെങ്കിലും
കമന്റ് നീക്കംചെയ്യൽ ഇല്ല. സ്ട്രിപ്പ് ചെയ്ത ബ്ലോക്കിന്റെ റൺ `rulesApplied`-ൽ `rtk:code-strip` എന്ന് ടാഗ് ചെയ്യപ്പെടുന്നു.

> **കുറിപ്പ് — GCF / ടാബുലാർ എൻകോഡിംഗ് ഒരു പ്രത്യേക എൻജിനാണ്.** "GCF"
> (Graph Compact Format) ടാബുലാർ/കോളമ്നാർ JSON എൻകോഡർ RTK-യിൽ **ഉൾപ്പെടുന്നില്ല**. പഴയ
> `omni-tabular` എൻകോഡറിന് പകരമായെത്തിയ ആ എൻകോഡർ **headroom** എൻജിനിലാണ്
> (`open-sse/services/compression/engines/headroom/`, വെൻഡർ ചെയ്ത കോഡെക്
> `headroom/gcf/`-നുള്ളിൽ). ഇവിടെ രേഖപ്പെടുത്തിയിരിക്കുന്ന RTK ഫിൽട്ടർ പൈപ്പ്ലൈനുമായി അതിന് ബന്ധമില്ല.

## കോൺഫിഗറേഷൻ

ആഗോള ക്രമീകരണങ്ങൾ `/api/settings/compression` വഴി ലഭ്യമാണ്. RTK-നിർദ്ദിഷ്ട ക്രമീകരണങ്ങൾ
`/api/context/rtk/config` വഴിയും ലഭ്യമാണ്.

```json
{
  "defaultMode": "stacked",
  "autoTriggerMode": "stacked",
  "autoTriggerTokens": 32000,
  "stackedPipeline": [
    { "engine": "rtk", "intensity": "standard" },
    { "engine": "caveman", "intensity": "full" }
  ],
  "rtkConfig": {
    "enabled": true,
    "intensity": "standard",
    "applyToToolResults": true,
    "applyToCodeBlocks": false,
    "applyToAssistantMessages": false,
    "enabledFilters": [],
    "disabledFilters": [],
    "maxLinesPerResult": 120,
    "maxCharsPerResult": 12000,
    "deduplicateThreshold": 3,
    "customFiltersEnabled": true,
    "trustProjectFilters": false,
    "rawOutputRetention": "never",
    "rawOutputMaxBytes": 1048576,
    "enableGrouping": false,
    "groupingThreshold": 3,
    "stripCodeComments": false,
    "preserveDocstrings": true
  }
}
```

`enabledFilters`, `disabledFilters` എന്നിവ ഫിൽട്ടർ ഐഡികൾ ഉപയോഗിക്കുന്നു, ഉദാഹരണത്തിന് `test-vitest` അല്ലെങ്കിൽ `git-diff`.

`rtkConfig`-ന്റെ പൂർണ്ണ ഘടന `open-sse/services/compression/types.ts`-ലെ `RtkConfig` /
`DEFAULT_RTK_CONFIG` നിർവചിക്കുന്നു. മുഴുവൻ ഒബ്ജക്റ്റും SQLite `key_value` പട്ടികയിൽ
`namespace = "compression"`, `key = "rtkConfig"` എന്നതിന് കീഴിൽ ഒറ്റ JSON മൂല്യമായി
നിലനിർത്തുന്നു (`src/lib/db/compression.ts`), വായിക്കുമ്പോൾ `normalizeRtkConfig` ഉപയോഗിച്ച് നോർമലൈസ് ചെയ്യുന്നു. അതിനാൽ താഴെയുള്ള ഓരോ ഫീൽഡും
— `enableGrouping`, `groupingThreshold`, `stripCodeComments`, `preserveDocstrings` എന്നിവ ഉൾപ്പെടെ —
ഒരേ സ്റ്റോറിലൂടെ റൗണ്ട്-ട്രിപ്പ് ചെയ്യുകയും പുനരാരംഭത്തിനു ശേഷവും നിലനിൽക്കുകയും ചെയ്യുന്നു.

| കീ                     | ഡിഫോൾട്ട് | ഉദ്ദേശ്യം                                                                                       |
| ---------------------- | --------- | ----------------------------------------------------------------------------------------------- |
| `deduplicateThreshold` | `3`       | എൻജിൻ മുഴുവൻ: ചുരുക്കാനുള്ള തുടർച്ചയായ സമാന വരികളുടെ കുറഞ്ഞ എണ്ണം (2–100 പരിധിയിൽ)              |
| `enableGrouping`       | `false`   | ഐച്ഛികം: ഏകദേശം തുല്യമായ തുടർച്ചയായ വരികളുടെ ശ്രേണികൾ ചുരുക്കുക                                 |
| `groupingThreshold`    | `3`       | ഗ്രൂപ്പിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്ന തുടർച്ചയായ സമാന വരികളുടെ കുറഞ്ഞ എണ്ണം                        |
| `stripCodeComments`    | `false`   | ഐച്ഛികം: ഫെൻസ്ഡ് കോഡ് ബ്ലോക്കുകളിൽനിന്ന് കമന്റുകൾ നീക്കംചെയ്യുക (`applyToCodeBlocks` ആവശ്യമാണ്) |
| `preserveDocstrings`   | `true`    | കമന്റുകൾ നീക്കംചെയ്യുമ്പോൾ JSDoc/`/** … */` ബ്ലോക്കുകൾ നിലനിർത്തുക                              |

## API

| റൂട്ട്                             | രീതി | ഉദ്ദേശ്യം                                                            |
| ---------------------------------- | ---- | -------------------------------------------------------------------- |
| `/api/context/rtk/config`          | GET  | RTK കോൺഫിഗ് വായിക്കുക                                                |
| `/api/context/rtk/config`          | PUT  | RTK കോൺഫിഗ് അപ്ഡേറ്റ് ചെയ്യുക                                        |
| `/api/context/rtk/filters`         | GET  | ഫിൽട്ടർ കാറ്റലോഗും ലോഡ് ഡയഗ്നോസ്റ്റിക്സും പട്ടികപ്പെടുത്തുക          |
| `/api/context/rtk/import`          | POST | RTK TOML schema v1 ഫയലുകൾ സാധൂകരിക്കുകയോ ഇൻസ്റ്റാൾ ചെയ്യുകയോ ചെയ്യുക |
| `/api/context/rtk/test`            | POST | ഒരു ടെക്സ്റ്റ് പേലോഡിനായുള്ള RTK കംപ്രഷൻ പ്രിവ്യൂ ചെയ്യുക            |
| `/api/context/rtk/raw-output/[id]` | GET  | നിലനിർത്തിയ, തിരുത്തിമറച്ച അസംസ്കൃത ഔട്ട്പുട്ട് വായിക്കുക            |
| `/api/compression/preview`         | POST | ഏതൊരു കംപ്രഷൻ മോഡും പ്രിവ്യൂ ചെയ്യുക                                 |

RTK ടെസ്റ്റ് പേലോഡ്:

```json
{
  "command": "npm test",
  "text": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed",
  "config": {
    "intensity": "standard"
  }
}
```

കംപ്രഷൻ പ്രിവ്യൂ പേലോഡ്:

```json
{
  "mode": "stacked",
  "messages": [
    {
      "role": "tool",
      "content": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed"
    }
  ],
  "config": {
    "rtkConfig": {
      "rawOutputRetention": "failures"
    }
  }
}
```

മാനേജ്മെന്റ് റൂട്ടുകൾക്ക് ഡാഷ്ബോർഡ് മാനേജ്മെന്റ് ഓത്ത് അല്ലെങ്കിൽ പൊരുത്തപ്പെടുന്ന API-key നയം ആവശ്യമാണ്.

RTK TOML സാധൂകരണ പേലോഡ്:

```json
{
  "action": "validate",
  "content": "schema_version = 1\n\n[filters.my-tool]\nmatch_command = \"^my-tool\\\\b\"\nmax_lines = 20\n"
}
```

സാധൂകരിച്ച ഫയൽ ആഗോളമായി ഇൻസ്റ്റാൾ ചെയ്യാൻ `"action": "install"` ഉപയോഗിക്കുക. നിലവിലുള്ള ആഗോള ഫയൽ മാറ്റിസ്ഥാപിക്കുന്നത് അവലോകനം ചെയ്ത് സ്ഥിരീകരിച്ചതിനുശേഷം മാത്രം
`"overwrite": true` ചേർക്കുക.

## അസംസ്കൃത ഔട്ട്പുട്ട് വീണ്ടെടുക്കൽ

RTK സാധാരണയായി കംപ്രസ് ചെയ്ത ടെക്സ്റ്റ് മാത്രം തിരികെ നൽകുന്നു. ഡീബഗ്ഗിങ്ങിനായി, തിരുത്തിമറച്ച അസംസ്കൃത ഔട്ട്പുട്ട് നിലനിർത്താൻ `rawOutputRetention`-ന് കഴിയും:

| മൂല്യം     | പ്രവർത്തനം                                                                    |
| ---------- | ----------------------------------------------------------------------------- |
| `never`    | അസംസ്കൃത ഔട്ട്പുട്ട് നിലനിർത്തരുത്                                            |
| `failures` | പരാജയമായിരിക്കാൻ സാധ്യതയുള്ള ഔട്ട്പുട്ട് മാത്രം നിലനിർത്തുക                   |
| `always`   | തിരുത്തിമറച്ച ശേഷം, കംപ്രസ് ചെയ്ത എല്ലാ RTK അസംസ്കൃത ഔട്ട്പുട്ടും നിലനിർത്തുക |

നിലനിർത്തിയ ഫയലുകൾ ഇതിന് കീഴിൽ എഴുതപ്പെടുന്നു:

```txt
DATA_DIR/rtk/raw-output/
```

സാധാരണ bearer token-കൾ, API കീകൾ, Slack token-കൾ, AWS access key-കൾ, assignment ശൈലിയിലുള്ള `token=...`, `secret=...`, `password=...` മൂല്യങ്ങൾ എന്നിവ ഉൾപ്പെടെയുള്ള രഹസ്യങ്ങൾ സ്ഥിരമായി സംഭരിക്കുന്നതിന് മുമ്പ് തിരുത്തിമറിക്കുന്നു. Analytics-ൽ pointer id, വലുപ്പം, hash metadata എന്നിവ മാത്രം സംഭരിക്കുന്നു.

## സ്ഥിരീകരണ ഗേറ്റ്

കേന്ദ്രീകൃത സ്ഥിരീകരണ ഗേറ്റ് ബാഹ്യ command-കൾ shell വഴി പ്രവർത്തിപ്പിക്കാതെ, ബിൽറ്റ്-ഇൻ inline filter test-കൾ പ്രവർത്തിപ്പിക്കുന്നു:

```bash
node --import tsx/esm --test tests/unit/compression/rtk-verify.test.ts
```

കൂടുതൽ വിപുലമായ RTK ഗേറ്റ്:

```bash
node --import tsx/esm --test \
  tests/unit/compression/rtk-*.test.ts \
  tests/unit/compression/pipeline-integration.test.ts \
  tests/unit/compression/context-compression-api.test.ts
```

റിലീസിന് മുമ്പ് വിപുലമായ compression ഗേറ്റ് പ്രവർത്തിപ്പിക്കുക:

```bash
node --import tsx/esm --test \
  tests/unit/compression/*.test.ts \
  tests/golden-set/*.test.ts \
  tests/integration/compression-pipeline.test.ts \
  tests/unit/api/compression/compression-api.test.ts
```

## RTK വിപുലീകരിക്കൽ

1. ഒരു filter JSON ഫയൽ ചേർക്കുകയോ അപ്ഡേറ്റ് ചെയ്യുകയോ ചെയ്യുക.
2. പ്രധാനപ്പെട്ട പ്രവർത്തനം തെളിയിക്കുന്ന കുറഞ്ഞത് ഒരു `tests[]` sample എങ്കിലും ഉൾപ്പെടുത്തുക.
3. പുതിയ command family-കൾക്കായി `tests/unit/compression/fixtures/rtk/`-ന് കീഴിൽ ഒരു fixture ചേർക്കുക.
4. പുതിയൊരു output class അവതരിപ്പിക്കുമ്പോൾ command detection coverage ചേർക്കുക.
5. സ്ഥിരീകരണ ഗേറ്റും വിപുലമായ RTK ഗേറ്റുകളും പ്രവർത്തിപ്പിക്കുക.
6. filter project-local ആണെങ്കിൽ, review-ന് ശേഷം മാത്രം `.rtk/filters.json` commit ചെയ്യുകയും `.rtk/trust.json` പുതുക്കുകയും ചെയ്യുക.

---

## തീവ്രതാ നിലകൾ (v3.8.16+)

**compression aggressiveness**-നും **സുരക്ഷ**യ്ക്കും ഇടയിൽ സന്തുലനം നൽകുന്ന **3 തീവ്രതാ നിലകൾ** RTK പിന്തുണയ്ക്കുന്നു. engine config-ലെ `config.intensity` വഴിയാണ് നില സജ്ജീകരിക്കുന്നത്.

### 3 നിലകൾ

| നില                  | വെട്ടിച്ചുരുക്കൽ പരിധി    | Token ലാഭം | അപകടസാധ്യത | ഏറ്റവും അനുയോജ്യമായത്                |
| -------------------- | ------------------------- | ---------- | ---------- | ------------------------------------ |
| `minimal`            | ഓരോ വിഭാഗത്തിലും 24 വരികൾ | ~20-40%    | വളരെ കുറവ് | നിർണായക context ഉള്ള production      |
| `standard` (default) | ഓരോ വിഭാഗത്തിലും 24 വരികൾ | ~50-70%    | കുറവ്      | ദൈനംദിന coding session-കൾ            |
| `aggressive`         | ഓരോ വിഭാഗത്തിലും 16 വരികൾ | ~70-90%    | ഇടത്തരം    | ദൈർഘ്യമേറിയ session-കൾ, പരമാവധി ലാഭം |

### വെട്ടിച്ചുരുക്കൽ എവിടെ സംഭവിക്കുന്നു

വെട്ടിച്ചുരുക്കൽ പരിധി `lineFilter.ts`-നെ ബാധിക്കുന്നു:

```ts
// open-sse/services/compression/engines/rtk/index.ts:329-330-ൽ നിന്ന്
config.intensity === "aggressive" ? 16 : 24,
config.intensity === "aggressive" ? 16 : 24,
```

ഓരോ വിഭാഗത്തിന്റെയും **തുടക്കവും** **അവസാനവും** സംരക്ഷിക്കപ്പെടുന്നു; വെട്ടിച്ചുരുക്കൽ ആരംഭിക്കുമ്പോൾ മധ്യഭാഗത്തെ ഉള്ളടക്കം ഒഴിവാക്കപ്പെടുന്നു.

### നിലനിർത്തുന്നതും മുറിച്ചുമാറ്റുന്നതും

| ഉള്ളടക്കം                    | minimal         | standard        | aggressive      |
| ---------------------------- | --------------- | --------------- | --------------- |
| Error-കൾ / stack trace-കൾ    | ✅ സംരക്ഷിക്കും | ✅ സംരക്ഷിക്കും | ✅ സംരക്ഷിക്കും |
| Test പരാജയങ്ങൾ               | ✅ സംരക്ഷിക്കും | ✅ സംരക്ഷിക്കും | ✅ സംരക്ഷിക്കും |
| Build error-കൾ               | ✅ സംരക്ഷിക്കും | ✅ സംരക്ഷിക്കും | ✅ സംരക്ഷിക്കും |
| വിജയിച്ച test-കൾ (വിശദമായത്) | ✅ സംരക്ഷിക്കും | 🟡 ചുരുക്കും    | 🟡 ചുരുക്കും    |
| പതിവ് output (info log-കൾ)   | 🟡 ചുരുക്കും    | 🟡 ചുരുക്കും    | ❌ ഒഴിവാക്കും   |
| Progress bar-കൾ              | 🟡 ചുരുക്കും    | ❌ ഒഴിവാക്കും   | ❌ ഒഴിവാക്കും   |
| Banner / ASCII art           | 🟡 ചുരുക്കും    | ❌ ഒഴിവാക്കും   | ❌ ഒഴിവാക്കും   |

### ശരിയായ തീവ്രത തിരഞ്ഞെടുക്കൽ

```
                  context നഷ്ടപ്പെടുന്നത് വിനാശകരമാണോ?
                  │
      ┌───────────┼───────────┐
      │           │           │
    അതെ         അല്ല       ഉറപ്പില്ല
      │           │           │
      ▼           │           │
   minimal        │           │
      │           │           │
      │           ▼           ▼
      │      throughput      ആദ്യം `standard`
      │      എത്രത്തോളം     പരീക്ഷിക്കുക (80%
      │      നിർണായകമാണ്?   സാഹചര്യങ്ങളിലും ഫലപ്രദം)
      │           │
      │      ┌────┴────┐
      │      │         │
      │    കുറവ്      ഉയർന്നത്
      │      │         │
      │      ▼         ▼
      │   standard   aggressive
      │      │         │
      └──────┴─────────┘
```

### തീവ്രത ക്രമീകരിക്കൽ

**ഓരോ combo-യ്ക്കും** (combo config-ൽ):

```json
{
  "combo": "my-coding-combo",
  "routing": {/* ... */},
  "compression": {
    "engine": "rtk",
    "intensity": "aggressive"
  }
}
```

**Programmatically**:

`rtkEngine` (`@omniroute/open-sse/services/compression/engines/rtk`) ഒരു
`CompressionEngine` ആണ്, അതിന് `updateConfig` method ഇല്ല. പകരം registry helper വഴി engine-ന്റെ config അപ്ഡേറ്റ് ചെയ്യുക:

```ts
import { updateEngineConfig } from "@omniroute/open-sse/services/compression/engines/registry";

updateEngineConfig("rtk", { intensity: "aggressive" });
```

### ഫലം സ്ഥിരീകരിക്കൽ

നിങ്ങൾ തിരഞ്ഞെടുത്ത തീവ്രതയിൽ നിങ്ങളുടെ filter സുരക്ഷിതമാണെന്ന് ഉറപ്പാക്കാൻ **സ്ഥിരീകരണ ഗേറ്റ്** (താഴെ കാണുക) ഉപയോഗിക്കുക:

```ts
import { runRtkFilterTests } from "omniroute/compression/engines/rtk/verify";

const result = runRtkFilterTests({ intensity: "aggressive" });
if (!result.passed) {
  console.error("Filters failed at aggressive intensity");
}
```

---

## ഇഷ്ടാനുസൃത ഫിൽട്ടർ വികസനം (v3.8.16+)

`engines/rtk/filters/` ഡയറക്ടറിയിൽ **49+ ബിൽറ്റ്-ഇൻ ഫിൽട്ടർ JSON ഫയലുകൾ** അടങ്ങിയിരിക്കുന്നു. ഡിഫോൾട്ടുകളിൽ ഉൾപ്പെടാത്ത ഇഷ്ടാനുസൃത ടൂളുകളിൽ നിന്നുള്ള ഔട്ട്പുട്ട് കംപ്രസ് ചെയ്യുന്നതിനായി നിങ്ങൾക്ക് സ്വന്തമായി ഫിൽട്ടറുകൾ ചേർക്കാം.

### ഫിൽട്ടർ സ്കീമ (Zod)

```ts
{
  "id": "string",                      // നിർബന്ധം. ഫിൽട്ടർ ഐഡന്റിഫയർ (kebab-case, ഉദാ., "python-traceback")
  "label": "string",                   // നിർബന്ധം. മനുഷ്യർക്ക് വായിക്കാവുന്ന ഫിൽട്ടർ പേര്
  "description": "string",             // ഐച്ഛികം (ഡിഫോൾട്ട്: ""). ഫിൽട്ടർ എന്ത് ചെയ്യുന്നു എന്നതിന്റെ ഹ്രസ്വ വിവരണം
  "category": "git|test|build|shell|docker|package|infra|cloud|generic",
  "priority": number,                  // ഐച്ഛികം (0-100, ഡിഫോൾട്ട്: 50). നിർവഹണ ക്രമം (ഉയർന്നത് = ആദ്യം)
  "match": {
    "commands": ["string"],            // പൊരുത്തപ്പെടുത്തേണ്ട കമാൻഡ് പേരുകൾ (ഉദാ., "python", "pytest")
    "patterns": ["string"],            // ഔട്ട്പുട്ടുമായി പൊരുത്തപ്പെടുത്തേണ്ട Regex പാറ്റേണുകൾ
    "outputTypes": ["string"]          // കണ്ടെത്തിയ ഔട്ട്പുട്ട് ക്ലാസുകൾ (ഉദാ., "test-failure")
  },
  "rules": {
    "stripAnsi": boolean,              // ഐച്ഛികം (ഡിഫോൾട്ട്: false). ANSI കളർ കോഡുകൾ നീക്കംചെയ്യുക
    "replace": [                       // കണ്ടെത്തി പകരംവയ്ക്കുന്നതിനുള്ള നിയമങ്ങൾ (ഡിഫോൾട്ട്: [])
      { "pattern": "regex", "replacement": "..." }
    ],
    "matchOutput": [                   // പാറ്റേൺ പൊരുത്തപ്പെട്ടാൽ ഉടൻ അവസാനിപ്പിക്കുക (ഡിഫോൾട്ട്: [])
      {
        "pattern": "regex",
        "message": "short summary",
        "unless": "regex"              // ഈ പാറ്റേൺ പൊരുത്തപ്പെടുകയാണെങ്കിൽ ഒഴിവാക്കുക
      }
    ],
    "includePatterns": ["string"],     // നിലനിർത്തേണ്ട വരികൾ (regex പാറ്റേണുകൾ, ഡിഫോൾട്ട്: [])
    "dropPatterns": ["string"],        // ഒഴിവാക്കേണ്ട വരികൾ (regex പാറ്റേണുകൾ, ഡിഫോൾട്ട്: [])
    "collapsePatterns": ["string"],    // ഒരൊറ്റ ആവർത്തനമായി ചുരുക്കേണ്ട വരികൾ (ഡിഫോൾട്ട്: [])
    "deduplicate": boolean,            // ഐച്ഛികം (ഡിഫോൾട്ട്: false). ആവർത്തിക്കുന്ന വരികൾ നീക്കംചെയ്യുക
    "truncateLineAt": number,          // ഐച്ഛികം (ഡിഫോൾട്ട്: 0). വരികളെ പരമാവധി അക്ഷരങ്ങളിലേക്ക് ചുരുക്കുക
    "maxLines": number,                // ഐച്ഛികം (ഡിഫോൾട്ട്: 0). ആകെ വരികളുടെ കർശനമായ പരമാവധി പരിധി
    "headLines": number,               // ഐച്ഛികം (ഡിഫോൾട്ട്: 20). പൊരുത്തപ്പെട്ട ഔട്ട്പുട്ടിലെ ആദ്യത്തെ N വരികൾ നിലനിർത്തുക
    "tailLines": number,               // ഐച്ഛികം (ഡിഫോൾട്ട്: 20). പൊരുത്തപ്പെട്ട ഔട്ട്പുട്ടിലെ അവസാനത്തെ N വരികൾ നിലനിർത്തുക
    "onEmpty": "string",               // ഐച്ഛികം (ഡിഫോൾട്ട്: ""). എല്ലാ വരികളും ഫിൽട്ടർ ചെയ്താൽ ഉപയോഗിക്കേണ്ട പകരം സന്ദേശം
    "filterStderr": boolean            // ഐച്ഛികം (ഡിഫോൾട്ട്: false). stderr ഔട്ട്പുട്ടും ഫിൽട്ടർ ചെയ്യുക
  },
  "preserve": {
    "errorPatterns": ["string"],       // എല്ലായ്പ്പോഴും നിലനിർത്തേണ്ട പാറ്റേണുകൾ (ഡിഫോൾട്ട്: [])
    "summaryPatterns": ["string"]      // അന്തിമ സംഗ്രഹ വരിക്കുള്ള പാറ്റേണുകൾ (ഡിഫോൾട്ട്: [])
  },
  "tests": [                           // പരിശോധനയ്ക്കുള്ള ഇൻലൈൻ ടെസ്റ്റുകൾ (ഡിഫോൾട്ട്: [])
    {
      "name": "string",               // നിർബന്ധം. ടെസ്റ്റിന്റെ പേര്
      "input": "sample output",        // നിർബന്ധം. സാമ്പിൾ ഇൻപുട്ട് ടെക്സ്റ്റ്
      "expected": "expected output",   // നിർബന്ധം. പ്രതീക്ഷിക്കുന്ന കംപ്രസ് ചെയ്ത ഔട്ട്പുട്ട്
      "command": "optional command"    // ഐച്ഛികം. കമാൻഡ് സന്ദർഭം
    }
  ]
}
```

### ഉദാഹരണം: Python ട്രേസ്ബാക്ക് ഫിൽട്ടർ

```json
{
  "id": "python-traceback",
  "label": "Python Traceback Filter",
  "description": "Compresses Python tracebacks to essential file/line locations and error type",
  "category": "test",
  "priority": 60,
  "match": {
    "commands": ["python", "python3", "pytest", "uv", "poetry"],
    "patterns": ["Traceback \\(most recent call last\\)", "Error", "Exception"],
    "outputTypes": ["error-traceback"]
  },
  "rules": {
    "stripAnsi": true,
    "includePatterns": [
      "Traceback \\(most recent call last\\)",
      "^\\s*File \".+\", line \\d+",
      "^\\s*[A-Z][a-zA-Z]+Error:",
      "^\\s*[A-Z][a-zA-Z]+Exception"
    ],
    "dropPatterns": ["site-packages/", "^\\s+[a-z_]+\\([^)]*\\)$"],
    "headLines": 5,
    "tailLines": 3,
    "maxLines": 25,
    "filterStderr": true
  },
  "preserve": {
    "errorPatterns": ["Error:", "Exception:", "Traceback"],
    "summaryPatterns": ["^[A-Z][a-zA-Z]+(?:Error|Exception):"]
  },
  "tests": [
    {
      "name": "preserves-error-type-and-location",
      "input": "Traceback (most recent call last):\n  File \"app.py\", line 42, in main\n    do_thing()\n  File \"lib/utils.py\", line 17, in helper\n    return 1 / 0\nZeroDivisionError: division by zero",
      "expected": "Traceback (most recent call last):\n  File \"app.py\", line 42, in main\n  File \"lib/utils.py\", line 17, in helper\nZeroDivisionError: division by zero",
      "command": "python app.py"
    }
  ]
}
```

### ഇഷ്ടാനുസൃത ഫിൽട്ടറുകൾ ലോഡ് ചെയ്യൽ

തിരിച്ചറിയപ്പെടുന്ന ഒരു ലൊക്കേഷനിൽ ഫയൽ സ്ഥാപിക്കുക:

```
~/.omniroute/rtk/filters/my-filter.json     # ഉപയോക്തൃ തലം
<project>/.rtk/filters/my-filter.json      # പ്രോജക്റ്റ് തലം
```

സ്റ്റാർട്ടപ്പിൽ `open-sse/services/compression/engines/rtk/filterLoader.ts`-ലെ `loadRtkFilters()` വഴി ഫിൽട്ടറുകൾ സ്വയമേവ ലോഡ് ചെയ്യപ്പെടുന്നു. ലോഡർ ഇനിപ്പറയുന്ന ലൊക്കേഷനുകളിൽനിന്ന് ഫിൽട്ടറുകൾ കണ്ടെത്തുന്നു:

- ബിൽറ്റ്-ഇൻ കാറ്റലോഗ്: `open-sse/services/compression/engines/rtk/filters/`
- ഉപയോക്തൃ ഡയറക്ടറി: `~/.omniroute/rtk/filters/`
- പ്രോജക്റ്റ് ഡയറക്ടറി: `<project>/.rtk/filters/`

പ്രോഗ്രാമാറ്റിക്കായി ഫിൽട്ടറുകൾ ലോഡ് ചെയ്യാൻ:

```ts
import { loadRtkFilters } from "@omniroute/open-sse/services/compression/engines/rtk/filterLoader";

// ഓപ്ഷനുകൾ: customFiltersEnabled (ഉപയോക്തൃ/പ്രോജക്റ്റ് ഫിൽട്ടറുകൾ ലോഡ് ചെയ്യുക, ഡിഫോൾട്ടായി പ്രവർത്തനക്ഷമമാണ്),
// trustProjectFilters, refresh.
const filters = loadRtkFilters({ customFiltersEnabled: true });
```

### സാധൂകരണം

ലോഡ് ചെയ്യുമ്പോൾ ഫിൽട്ടറുകൾ Zod സ്കീമയ്ക്കെതിരെ സാധൂകരിക്കപ്പെടുന്നു. തെറ്റായ ഘടനയുള്ള ഒരു ഫിൽട്ടർ ലോഡ് ചെയ്യുന്നതിൽ പരാജയപ്പെടുകയും ഒരു പിശക് ലോഗ് ചെയ്യുകയും ചെയ്യും:

```
RTK_FILTER_LOADER: filter "my-filter" failed validation:
  - rules.replace.0.pattern: Invalid regex
  - match.commands: must not be empty
```

ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള എല്ലാ ഫിൽട്ടറുകളും സാധൂകരിക്കുന്നതിന്, `open-sse/services/compression/engines/rtk/verify.ts`-ൽനിന്ന് എക്സ്പോർട്ട് ചെയ്യുന്ന `runRtkFilterTests()` വിളിക്കുക.

### മികച്ച രീതികൾ

1. **എപ്പോഴും `tests[]` ഉൾപ്പെടുത്തുക** — അവ നിങ്ങളുടെ ഫിൽട്ടർ പ്രവർത്തിക്കുന്നുവെന്ന് തെളിയിക്കുകയും റിഗ്രഷനുകൾ തടയുകയും ചെയ്യുന്നു
2. **ഷോർട്ട് സർക്യൂട്ടുകൾക്കായി `matchOutput` ഉപയോഗിക്കുക** — ഒരൊറ്റ വരി കാര്യത്തിന്റെ സാരാംശം വ്യക്തമാക്കുന്നുവെങ്കിൽ, മുഴുവൻ ബ്ലോക്കും മാറ്റിസ്ഥാപിക്കുക
3. **`strip`-നേക്കാൾ `keep` തിരഞ്ഞെടുക്കുക** — വ്യക്തമായ "എപ്പോഴും നിലനിർത്തുക" നിയമങ്ങൾ "എപ്പോഴും നീക്കംചെയ്യുക" എന്നതിനേക്കാൾ സുരക്ഷിതമാണ്
4. **3 തീവ്രതാ നിലകളിലും പരീക്ഷിക്കുക** — `minimal` ഒന്നും ചെയ്യാതിരിക്കണം, `aggressive` അപ്പോഴും പിശകുകൾ നിലനിർത്തണം
5. **`unless` ഫീൽഡ് ഉപയോഗിക്കുക** — "X ഉണ്ടെങ്കിൽ ട്രിഗർ ചെയ്യരുത്" എന്ന വ്യവസ്ഥ ഉപയോഗിച്ച് ഷോർട്ട് സർക്യൂട്ടുകൾക്ക് സംരക്ഷണം നൽകുക

---

## അസംസ്കൃത ഔട്ട്പുട്ട് വീണ്ടെടുക്കലും പരിശോധനാ ഗേറ്റും

RTK ഔട്ട്പുട്ട് ശക്തമായി കംപ്രസ് ചെയ്യുമ്പോൾ, ഡീബഗ്ഗിംഗ്, ഓഡിറ്റ് അല്ലെങ്കിൽ റീപ്ലേ എന്നിവയ്ക്കായി നിങ്ങൾക്ക് **യഥാർത്ഥ ടെക്സ്റ്റ് വീണ്ടെടുക്കാം**.

### അസംസ്കൃത ഔട്ട്പുട്ട് വീണ്ടെടുക്കൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു

```
യഥാർത്ഥ ഔട്ട്പുട്ട് (10K ടോക്കണുകൾ)
        │
        ▼
RTK കംപ്രസ് ചെയ്യുന്നു (rawOutput.enabled=true ഉപയോഗിച്ച്)
        │
        ├─▶ കംപ്രസ് ചെയ്ത ഔട്ട്പുട്ട് (2K ടോക്കണുകൾ)  ──▶ LLM-ലേക്ക്
        │
        └─▶ യഥാർത്ഥ ഔട്ട്പുട്ട് (10K ടോക്കണുകൾ)       ──▶ DB-യിൽ സംഭരിക്കുന്നു
                                                           (request_id വഴി ലിങ്ക് ചെയ്തത്)
```

### അസംസ്കൃത ഔട്ട്പുട്ട് സംഭരണം പ്രവർത്തനക്ഷമമാക്കൽ

**ഓരോ അഭ്യർത്ഥനയ്ക്കും** (കോംബോ കോൺഫിഗിൽ):

```json
{
  "compression": {
    "engine": "rtk",
    "intensity": "aggressive",
    "rawOutput": {
      "enabled": true,
      "maxBytes": 1048576 // 1MB പരിധി
    }
  }
}
```

**ഡിഫോൾട്ട്**: `rawOutput.enabled: false` (സംഭരണ ഇടം ലാഭിക്കുന്നു).

### സംഭരണച്ചെലവ്

| ഓരോ അഭ്യർത്ഥനയ്ക്കും             | 1MB പരിധി    | 10MB പരിധി    |
| -------------------------------- | ------------ | ------------- |
| ശരാശരി കംപ്രസ് ചെയ്ത ഔട്ട്പുട്ട് | ~5KB         | ~5KB          |
| സംഭരിച്ച അസംസ്കൃത ഔട്ട്പുട്ട്    | ~50-500KB    | ~500KB-5MB    |
| പ്രതിദിനം 1000 അഭ്യർത്ഥനകളോടെ    | 50-500MB/day | 500MB-5GB/day |

> **ശുപാർശ**: എല്ലായ്പ്പോഴും പ്രവർത്തനക്ഷമമാക്കുന്നതിനു പകരം, **ഡീബഗ്ഗിംഗ് സെഷനുകൾക്കോ** **സാമ്പിൾ അടിസ്ഥാനത്തിലുള്ള ഓഡിറ്റിംഗിനോ** മാത്രം അസംസ്കൃത ഔട്ട്പുട്ട് പ്രവർത്തനക്ഷമമാക്കുക.

### യഥാർത്ഥ ഔട്ട്പുട്ട് വീണ്ടെടുക്കൽ

```ts
import { readRtkRawOutput } from "omniroute/compression/engines/rtk/rawOutput";

const raw = readRtkRawOutput(pointerId); // കംപ്രഷൻ സ്ഥിതിവിവരക്കണക്കുകളിൽ നിന്നുള്ള pointerId
if (raw) {
  console.log("Original output:", raw);
}
```

കംപ്രഷനുശേഷം `CompressionStats.rtkRawOutputPointers[]`-ൽ `pointerId` ലഭിക്കും.
ഫംഗ്ഷൻ സിഗ്നേച്ചറിനായി `open-sse/services/compression/engines/rtk/rawOutput.ts:102` കാണുക.

### പരിശോധനാ ഗേറ്റ്

**RTK ഫിൽട്ടർ പരിശോധന** (`open-sse/services/compression/engines/rtk/verify.ts`) എല്ലാ ഫിൽട്ടറുകളെയും അവയുടെ `tests[]`-നെതിരെ സാധൂകരിക്കുകയും 3 തീവ്രതാ നിലകളിലും പ്രവർത്തനം ശരിയാണെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നു.

പരിശോധന പ്രവർത്തിപ്പിക്കാൻ **`runRtkFilterTests()` വിളിക്കുക**:

```ts
import { runRtkFilterTests } from "open-sse/services/compression/engines/rtk/verify";

const result = runRtkFilterTests();
console.log(`Passed: ${result.outcomes.filter((o) => o.passed).length}`);
console.log(`Failed: ${result.outcomes.filter((o) => !o.passed).length}`);
if (!result.passed) {
  console.error("Filters failed verification");
  result.outcomes
    .filter((o) => !o.passed)
    .forEach((o) => {
      console.error(
        `  - ${o.filterId} / ${o.testName}: expected "${o.expected}", got "${o.actual}"`
      );
    });
}
```

**ഇത് സാധൂകരിക്കുന്ന കാര്യങ്ങൾ**:

1. എല്ലാ ഫിൽട്ടറുകളും ലോഡ് ചെയ്യുകയും സ്കീമ സാധൂകരണം വിജയിക്കുകയും ചെയ്യുന്നു
2. ഓരോ `tests[]` എൻട്രിയും പ്രതീക്ഷിച്ച ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നു
3. `minimal` തീവ്രത ഒരു no-op ആണ് (യഥാർത്ഥ ഉള്ളടക്കം സംരക്ഷിക്കുകയും ഘടനാപരമായ ഫിൽട്ടറുകൾ മാത്രം പ്രയോഗിക്കുകയും ചെയ്യുന്നു)
4. `aggressive` തീവ്രത പിശകുകൾ, ടെസ്റ്റ് പരാജയങ്ങൾ, സ്റ്റാക്ക് ട്രേസുകൾ എന്നിവ സംരക്ഷിക്കുന്നു
5. കംപ്രസ് ചെയ്ത ഔട്ട്പുട്ട് ഒരിക്കലും യഥാർത്ഥ ഇൻപുട്ടിനെക്കാൾ വലുതാകില്ല

- ഉറവിടം: `open-sse/services/compression/engines/rtk/` (63 ഫയലുകൾ, ~70KB)

- **ഒരു ഫിൽട്ടർ മാറ്റം ലയിപ്പിക്കുന്നതിന് മുമ്പ്** — ടെസ്റ്റുകൾ വിജയിക്കുന്നുവെന്ന് എല്ലായ്പ്പോഴും ഉറപ്പാക്കുക
- **RTK എഞ്ചിൻ അപ്ഗ്രേഡ് ചെയ്തശേഷം** — സ്കീമ മാറിയിട്ടുണ്ടാകാം
- **മോണിറ്ററിംഗിൽ ഇടയ്ക്കിടെ** — ടെസ്റ്റ് ഫിക്ചറുകളിലെ വ്യതിയാനങ്ങളിൽ നിന്ന് സംരക്ഷിക്കുന്നു
- **ഒരു പുതിയ ടൂൾ/കമാൻഡ് കുടുംബം ചേർക്കുമ്പോൾ** — പുതിയ ഫിൽട്ടർ പ്രവർത്തിക്കുന്നുവെന്ന് തെളിയിക്കുന്നു

---

## ഇതും കാണുക

- [COMPRESSION_GUIDE.md](./COMPRESSION_GUIDE.md) — സമ്പൂർണ്ണ കംപ്രഷൻ പൈപ്പ്ലൈൻ അവലോകനം
- [COMPRESSION_ENGINES.md](./COMPRESSION_ENGINES.md) — എൻജിൻ രജിസ്ട്രിയും ബിൽറ്റ്-ഇൻ എൻജിനുകളും
- [EXTENDING_COMPRESSION.md](./EXTENDING_COMPRESSION.md) — കസ്റ്റം എൻജിനുകൾ, ഭാഷാ പാക്കുകൾ, സ്റ്റാക്ക് ചെയ്ത പൈപ്പ്ലൈനുകൾ
- ഉറവിടം: `open-sse/services/compression/engines/rtk/` (63 ഫയലുകൾ, ~70KB)