mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-20 22:02:19 +03:00

Files

Diego Rodrigues de Sa e Souza 8feea123bb feat(docs): mirror every docs/ page in all 65 locales (#14106 )

* feat(docs): mirror every docs/ page in all 65 locales

Extends the documentation mirrors from the 22-page core set (#13940) to
every Markdown page under docs/: 152 sources x 65 locales = 9,880 mirrors
(6,208 new), language bars rewritten for the full locale list, state
adopted so the blocking drift gate now covers all 152 pages.

run-translation.mjs: an oversized block made only of table rows or list
items (PROVIDER_REFERENCE.md 244-row table, FREE_TIERS.md 71-item list) is
cut at item boundaries and rejoined without a blank line — the single
16-40 KB request outlived the backend socket for verbose scripts. 48
older mirrors whose tables had lost rows were retranslated with --force.

* docs(i18n): refresh mirrors for the sources the base changed since the branch cut

Section-level retranslation of the 29 docs (and README.md) whose source
or mirrors moved on release/v3.8.51 during the run, then state adoption;
the drift gate is green again on the merged tree.

2026-09-18 13:16:46 -03:00

68 KiB

Raw Blame History

RTK Compression (മലയാളം)

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

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

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

rtk -> caveman

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

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

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 താഴെപ്പറയുന്ന ക്രമത്തിൽ ഫിൽട്ടറുകൾ ലോഡ് ചെയ്യുന്നു:

വിശ്വസനീയമാണെങ്കിൽ മാത്രം .rtk/filters.toml, .rtk/filters.json എന്നിവയിൽ നിന്നുള്ള പ്രോജക്റ്റ് ഫിൽട്ടറുകൾ.
DATA_DIR/rtk/filters.toml, DATA_DIR/rtk/filters.json എന്നിവയിൽ നിന്നുള്ള ഗ്ലോബൽ ഫിൽട്ടറുകൾ.
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-ൽ അടങ്ങിയിരിക്കുന്നു.

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

{
  "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-ൽ വിവരിച്ചിരിക്കുന്ന JSON സ്കീമ ഉപയോഗിക്കുന്നു. റൺടൈം ഈ ഘട്ടങ്ങൾ ക്രമത്തിൽ പ്രയോഗിക്കുന്നു:

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 രണ്ട് സ്വതന്ത്ര തലങ്ങളിൽ ആവർത്തിക്കുന്ന വരികളെ സംയോജിപ്പിക്കുന്നു:

ഓരോ ഫിൽട്ടറിനുമുള്ള deduplicate (ഓപ്റ്റ്-ഇൻ, ഡിഫോൾട്ട് false). ഒരു ഫിൽട്ടറിന് rules.deduplicate: true ആയി സജ്ജീകരിച്ച്, വെട്ടിച്ചുരുക്കുന്നതിന് മുമ്പ് ആ ഫിൽട്ടറുമായി പൊരുത്തപ്പെട്ട ഔട്ട്പുട്ടിനുള്ളിലെ തുടർച്ചയായ ആവർത്തന വരികളെ സംയോജിപ്പിക്കാം. ഇത് lineFilter.ts-നുള്ളിലാണ് പ്രവർത്തിക്കുന്നത്. ലെഗസി ഫിൽട്ടറുകൾക്ക്, ഫിൽട്ടർ collapsePatterns നിർവചിക്കുമ്പോൾ ഇത് സ്വയമേവ പ്രവർത്തനക്ഷമമാക്കപ്പെടും. സ്കീമ: open-sse/services/compression/engines/rtk/filterSchema.ts-ൽ deduplicate: z.boolean().default(false).
എൻജിൻ-വ്യാപകമായ 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 വഴിയും ലഭ്യമാണ്.

{
  "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 ടെസ്റ്റ് പേലോഡ്:

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

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

{
  "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 സാധൂകരണ പേലോഡ്:

{
  "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 അസംസ്കൃത ഔട്ട്പുട്ടും നിലനിർത്തുക

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

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-കൾ പ്രവർത്തിപ്പിക്കുന്നു:

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

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

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 ഗേറ്റ് പ്രവർത്തിപ്പിക്കുക:

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 വിപുലീകരിക്കൽ

ഒരു filter JSON ഫയൽ ചേർക്കുകയോ അപ്ഡേറ്റ് ചെയ്യുകയോ ചെയ്യുക.
പ്രധാനപ്പെട്ട പ്രവർത്തനം തെളിയിക്കുന്ന കുറഞ്ഞത് ഒരു tests[] sample എങ്കിലും ഉൾപ്പെടുത്തുക.
പുതിയ command family-കൾക്കായി tests/unit/compression/fixtures/rtk/-ന് കീഴിൽ ഒരു fixture ചേർക്കുക.
പുതിയൊരു output class അവതരിപ്പിക്കുമ്പോൾ command detection coverage ചേർക്കുക.
സ്ഥിരീകരണ ഗേറ്റും വിപുലമായ RTK ഗേറ്റുകളും പ്രവർത്തിപ്പിക്കുക.
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-നെ ബാധിക്കുന്നു:

// 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-ൽ):

{
  "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 അപ്ഡേറ്റ് ചെയ്യുക:

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

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

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

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

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)

{
  "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 ട്രേസ്ബാക്ക് ഫിൽട്ടർ

{
  "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/

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

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() വിളിക്കുക.

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

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

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

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

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

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

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

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

{
  "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

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

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

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() വിളിക്കുക:

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}"`
      );
    });
}

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

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

ഉറവിടം: open-sse/services/compression/engines/rtk/ (63 ഫയലുകൾ, ~70KB)
ഒരു ഫിൽട്ടർ മാറ്റം ലയിപ്പിക്കുന്നതിന് മുമ്പ് — ടെസ്റ്റുകൾ വിജയിക്കുന്നുവെന്ന് എല്ലായ്പ്പോഴും ഉറപ്പാക്കുക
RTK എഞ്ചിൻ അപ്ഗ്രേഡ് ചെയ്തശേഷം — സ്കീമ മാറിയിട്ടുണ്ടാകാം
മോണിറ്ററിംഗിൽ ഇടയ്ക്കിടെ — ടെസ്റ്റ് ഫിക്ചറുകളിലെ വ്യതിയാനങ്ങളിൽ നിന്ന് സംരക്ഷിക്കുന്നു
ഒരു പുതിയ ടൂൾ/കമാൻഡ് കുടുംബം ചേർക്കുമ്പോൾ — പുതിയ ഫിൽട്ടർ പ്രവർത്തിക്കുന്നുവെന്ന് തെളിയിക്കുന്നു

ഇതും കാണുക

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

68 KiB Raw Blame History Unescape Escape