# 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) · 🇮🇳 [ml](../../../ml/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) · 🇸🇰 [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` සිට RTK ටෝකන `~23,900` දක්වා අඩු වන අතර, එය `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` සකසා ඇත. - `.rtk/trust.json` හි ව්යාපෘති පෙරහන් ගොනුවට ගැළපෙන SHA-256 හැෂ් අගය අඩංගු වේ. විශ්වාස ගොනු උදාහරණය: ```json { "filtersSha256": "0123456789abcdef...", "filtersTomlSha256": "fedcba9876543210..." } ``` හැෂ් වෙන වෙනම පවතී: `filtersSha256` විසින් `.rtk/filters.json` විශ්වාස කරන අතර, `filtersTomlSha256` විසින් `.rtk/filters.toml` විශ්වාස කරයි. එක් ගොනුවක් සංස්කරණය කිරීමෙන් අවලංගු වන්නේ එහිම විශ්වාස ඇතුළත් කිරීම පමණි. ගෝලීය ගොනු පරිපාලකයා විසින් ස්ථාපනය කරනු ලබන අතර පවතින ගෝලීය-පෙරහන් විශ්වාස හැසිරීම භාවිත කරයි. අභිරුචි පෙරහන් එක් පෙරහන් වස්තුවක් හෝ පෙරහන් වස්තු අරාවක් විය හැක. වලංගු නොවන අභිරුචි පෙරහන් මඟහැර ` /api/context/rtk/filters` රෝගනිර්ණවලින් වාර්තා කෙරේ. වලංගු නොවන අන්තර්ගත පෙරහන් වහාම අසමත් වේ. ## RTK TOML schema v1 අනුකූලතාව OmniRoute හට RTK TOML schema v1 භාවිතයෙන් ප්රකාශනාත්මක පෙරහන් ගොනු විග්රහ කිරීමට, වලංගු කිරීමට, පරීක්ෂා කිරීමට සහ ස්ථාපනය කිරීමට හැකිය. සහාය දක්වන ක්ෂේත්ර වන්නේ `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.]]` පේළිගත පරීක්ෂණ වේ. නොදන්නා ක්ෂේත්ර, වලංගු නොවන හෝ අනාරක්ෂිත නිත්ය ප්රකාශන, එකවර ඇති ඉවත් කිරීමේ/රඳවාගැනීමේ රීති, 1 MiB ඉක්මවන ගොනු, සහ නොදන්නා පෙරහන් වෙත යොමු කිරීම් ප්රතික්ෂේප කෙරේ. පේළිගත පරීක්ෂණ අසමත් වන ගොනුවක් පරීක්ෂා කිරීම සඳහා වලංගු කළ හැකි නමුත් එය ස්ථාපනය කිරීමට හෝ පූරණය කිරීමට නොහැක. අභිරුචි ගොනු පූරණය කිරීමේ අසමත්වීම් තවදුරටත් fail-open ලෙස පවතී: වලංගු නොවන ගොනුව මඟහැර ඉතිරි පෙරහන් දිගටම ක්රියා කරයි. සේවාලාභියා මෙවලම් ප්රතිදානය දැනටමත් ග්රහණය කරගත් පසුව OmniRoute වෙත එය ලැබෙන බැවින්, `filter_stderr = true` මඟින් ක්රියාවලි ග්රහණය වෙනස් කළ නොහැක. මෙම ක්ෂේත්රය කිසිදු ක්රියාවක් නොකරන විකල්පයක් ලෙස පිළිගන්නා අතර වලංගුකරණය අනතුරු ඇඟවීමක් ලබා දෙයි. මෙය හිතාමතාම **RTK TOML schema v1 අනුකූලතාව** ලෙස විස්තර කරන අතර, RTK ක්රියාත්මක කළ හැකි ගොනුව, shell hooks, 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 schema භාවිත කරයි. ධාවන පරිසරය මෙම අදියර අනුපිළිවෙළින් යොදයි: ```txt stripAnsi -> filterStderr -> replace -> matchOutput -> පේළි ඉවත් කිරීම/ඇතුළත් කිරීම -> truncateLineAt -> head/tail/maxLines -> onEmpty ``` වැදගත් ක්ෂේත්ර: | ක්ෂේත්රය | අරමුණ | | ---------------------------- | ---------------------------------------------------------------- | | `rules.stripAnsi` | ගැළපීමට පෙර terminal වර්ණ/පාලන අනුක්රම ඉවත් කිරීම | | `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[]` | සත්යාපන දොරටුව භාවිත කරන පේළිගත නියැදි | ගොඩනඟා ඇති පෙරහන්වල පේළිගත `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` වූ විට, RTK විසින් JavaScript සහ TypeScript වැටකින් වට කළ කුට්ටිවලින් විවරණ ඉවත් කරයි. ඓතිහාසිකව මෙම සලකුණ කියවන ලද නමුත් කිසිවිටෙක යොදා නොගත් බැවින්, නිහඬ නිෂ්පාදන වෙනසක් වළක්වා ගැනීමට පෙරනිමිය "සුරකින්න" ලෙසම පවතී. - `preserveDocstrings` (පෙරනිමිය `true`) — විවරණ ඉවත් කරන විට, JSDoc/`/** … */` කුට්ටි විවරණ තබා ගනී (ඒවා වැය කරන බයිට්වලට වඩා වටිනා API ප්රලේඛන රැගෙන යයි). ඒවාද ඉවත් කිරීමට `false` ලෙස සකසන්න. විවරණ ඉවත් කිරීම `open-sse/services/compression/engines/rtk/codeStripper.ts` තුළ ක්රියාත්මක කර ඇත. එය **TypeScript විග්රහකය** (regex එකක් නොවේ) භාවිත කරන බැවින් තන්තු, අච්චු සහ regex ලිටරල් කිසිවිටෙක විවරණ ලෙස වරදවා නොගනී. තවද JSX අනාවරණය වූ විට එය සම්පූර්ණයෙන්ම ක්රියාව නවත්වයි (එමඟින් JSX ප්රකාශන-බහාලුම් විවරණ කිසිවිටෙක දූෂිත නොවේ). විවරණ ඉවත් කිරීම දැනට අදාළ වන්නේ **JavaScript සහ TypeScript සඳහා පමණි** — ඉවත්කාරකයේ `CodeLanguage` කට්ටලයේ ඇති අනෙකුත් භාෂා (Python, Rust, Go, Ruby, Java) සඳහා හිස් පේළි සහ සුදු ඉඩ හකුළන නමුත් විවරණ ඉවත් නොකරයි. විවරණ ඉවත් කළ කුට්ටි ධාවනය `rulesApplied` තුළ `rtk:code-strip` ලෙස ටැග් කෙරේ. > **සටහන — GCF / වගුමය කේතනය වෙනම එන්ජිමකි.** RTK තුළ "GCF" > (Graph Compact Format) වගුමය/තීරුමය JSON කේතකය අඩංගු **නොවේ**. පැරණි > `omni-tabular` කේතකයක් ප්රතිස්ථාපනය කළ එම කේතකය **headroom** එන්ජිම තුළ පවතී > (`open-sse/services/compression/engines/headroom/`, ඒ සමඟ ඇතුළත් කර ඇති codec එක > `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` සඳහා පෙරහන් ids භාවිත කරයි, උදාහරණයක් ලෙස `test-vitest` හෝ `git-diff`. සම්පූර්ණ `rtkConfig` ව්යුහය `open-sse/services/compression/types.ts` තුළ ඇති `RtkConfig` / `DEFAULT_RTK_CONFIG` මඟින් නිර්වචනය කර ඇත. සම්පූර්ණ object එකම SQLite `key_value` වගුවේ `namespace = "compression"`, `key = "rtkConfig"` යටතේ තනි JSON අගයක් ලෙස සුරැකේ (`src/lib/db/compression.ts`), සහ කියවීමේදී `normalizeRtkConfig` මඟින් සාමාන්යකරණය කෙරේ. එබැවින් පහත සෑම field එකක්ම — `enableGrouping`, `groupingThreshold`, `stripCodeComments`, සහ `preserveDocstrings` ඇතුළුව — එකම ගබඩාව හරහා ආපසු ලියා-කියවා ගත හැකි අතර නැවත ආරම්භ කිරීමකින් පසුවද පවතී. | යතුර | පෙරනිමිය | අරමුණ | | ---------------------- | -------- | ---------------------------------------------------------------------------------------------------- | | `deduplicateThreshold` | `3` | සමස්ත engine එකටම: හකුළා දැමීමට අවශ්ය අවම අඛණ්ඩ සමාන පේළි ගණන (2–100 අතර සීමා කෙරේ) | | `enableGrouping` | `false` | විකල්පයෙන් සක්රිය කළ හැක: ආසන්න වශයෙන් සමාන අඛණ්ඩ පේළි පෙළ හකුළයි | | `groupingThreshold` | `3` | සමූහගත කිරීම ක්රියාත්මක කරන අවම අඛණ්ඩ සමාන-පේළි පෙළ දිග | | `stripCodeComments` | `false` | විකල්පයෙන් සක්රිය කළ හැක: වැටකළ code blocks වෙතින් comments ඉවත් කරයි (`applyToCodeBlocks` අවශ්ය වේ) | | `preserveDocstrings` | `true` | comments ඉවත් කරන විට, JSDoc/`/** … */` blocks තබා ගනී | ## 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 | එක් text payload එකක් සඳහා RTK සම්පීඩනය පෙරදසුන් කිරීම | | `/api/context/rtk/raw-output/[id]` | GET | රඳවාගත්, සංවේදී කොටස් සැඟවූ raw output කියවීම | | `/api/compression/preview` | POST | ඕනෑම සම්පීඩන mode එකක් පෙරදසුන් කිරීම | RTK පරීක්ෂණ payload: ```json { "command": "npm test", "text": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed", "config": { "intensity": "standard" } } ``` සම්පීඩන පෙරදසුන් payload: ```json { "mode": "stacked", "messages": [ { "role": "tool", "content": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed" } ], "config": { "rtkConfig": { "rawOutputRetention": "failures" } } } ``` කළමනාකරණ routes සඳහා dashboard කළමනාකරණ සත්යාපනය හෝ ගැළපෙන API-key ප්රතිපත්තිය අවශ්ය වේ. RTK TOML වලංගුකරණ payload: ```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 tokens, API keys, Slack tokens, AWS access keys, සහ පැවරුම් ආකාරයේ `token=...`, `secret=...`, `password=...` අගයන් ඇතුළුව රහස්, ස්ථිරව සුරැකීමට පෙර ඉවත් කරනු ලැබේ. විශ්ලේෂණ තුළ ගබඩා කරන්නේ දර්ශක හැඳුනුම්කාරකය, ප්රමාණය සහ hash පාරදත්ත පමණි. ## සත්යාපන ද්වාරය ඉලක්කගත සත්යාපන ද්වාරය බාහිර විධාන ක්රියාත්මක නොකර, අන්තර්ගත built-in filter පරීක්ෂණ ධාවනය කරයි: ```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 ``` නිකුතුවට පෙර පුළුල් සම්පීඩන ද්වාරය ධාවනය කරන්න: ```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[]` නියැදියක් ඇතුළත් කරන්න. 3. නව විධාන පවුල් සඳහා `tests/unit/compression/fixtures/rtk/` යටතේ fixture එකක් එක් කරන්න. 4. නව ප්රතිදාන පන්තියක් හඳුන්වා දීමේදී විධාන හඳුනාගැනීමේ ආවරණය එක් කරන්න. 5. සත්යාපන සහ පුළුල් RTK ද්වාර ධාවනය කරන්න. 6. filter එක ව්යාපෘතියට-දේශීය නම්, සමාලෝචනයෙන් පසුව පමණක් `.rtk/filters.json` commit කර `.rtk/trust.json` නැවුම් කරන්න. --- ## තීව්රතා මට්ටම් (v3.8.16+) RTK, **සම්පීඩන ආක්රමණශීලීත්වය** සහ **ආරක්ෂාව** අතර තුලනය කරන **තීව්රතා මට්ටම් 3කට** සහාය දක්වයි. මට්ටම engine config තුළ `config.intensity` හරහා සකසනු ලැබේ. ### මට්ටම් 3 | මට්ටම | කප්පාදු සීමාව | Token ඉතිරිය | අවදානම | වඩාත් සුදුසු වන්නේ | | -------------------- | ------------------ | ------------ | ------- | -------------------------------------- | | `minimal` | එක් කොටසකට පේළි 24 | ~20-40% | ඉතා අඩු | තීරණාත්මක සන්දර්භ සහිත production සඳහා | | `standard` (පෙරනිමි) | එක් කොටසකට පේළි 24 | ~50-70% | අඩු | දෛනික coding සැසි සඳහා | | `aggressive` | එක් කොටසකට පේළි 16 | ~70-90% | මධ්යම | දිගු සැසි, උපරිම ඉතිරිකිරීම් සඳහා | ### කප්පාදුව සිදු වන ස්ථානය කප්පාදු සීමාව `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 | | ----------------------------- | -------------- | -------------- | -------------- | | දෝෂ / stack traces | ✅ සුරැකේ | ✅ සුරැකේ | ✅ සුරැකේ | | පරීක්ෂණ අසාර්ථකවීම් | ✅ සුරැකේ | ✅ සුරැකේ | ✅ සුරැකේ | | Build දෝෂ | ✅ සුරැකේ | ✅ සුරැකේ | ✅ සුරැකේ | | සාර්ථක පරීක්ෂණ (විස්තරාත්මක) | ✅ සුරැකේ | 🟡 හකුළනු ලැබේ | 🟡 හකුළනු ලැබේ | | සාමාන්ය ප්රතිදානය (info logs) | 🟡 හකුළනු ලැබේ | 🟡 හකුළනු ලැබේ | ❌ ඉවත් කෙරේ | | ප්රගති තීරු | 🟡 හකුළනු ලැබේ | ❌ ඉවත් කෙරේ | ❌ ඉවත් කෙරේ | | Banner / ASCII art | 🟡 හකුළනු ලැබේ | ❌ ඉවත් කෙරේ | ❌ ඉවත් කෙරේ | ### නිවැරදි තීව්රතාව තෝරාගැනීම ``` සන්දර්භය අහිමි වීම විනාශකාරීද? │ ┌───────────┼───────────┐ │ │ │ ඔව් නැත විශ්වාස නැත │ │ │ ▼ │ │ minimal │ │ │ │ │ │ ▼ ▼ │ throughput පළමුව `standard` උත්සාහ කරන්න │ කෙතරම් (අවස්ථාවලින් 80%ක් සඳහා │ තීරණාත්මකද? ක්රියා කරයි) │ │ │ ┌────┴────┐ │ │ │ │ අඩු ඉහළ │ │ │ │ ▼ ▼ │ standard aggressive │ │ │ └──────┴─────────┘ ``` ### තීව්රතාව වින්යාස කිරීම **එක් එක් combo එක සඳහා** (combo config තුළ): ```json { "combo": "my-coding-combo", "routing": {/* ... */}, "compression": { "engine": "rtk", "intensity": "aggressive" } } ``` **ක්රමලේඛමය ලෙස**: `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 අසාර්ථක විය"); } ``` --- ## අභිරුචි පෙරහන් සංවර්ධනය (v3.8.16+) `engines/rtk/filters/` නාමාවලිය තුළ **ගොඩනඟා ඇති පෙරහන් JSON ගොනු 49කට වැඩි ප්රමාණයක්** අඩංගු වේ. පෙරනිමි මඟින් ආවරණය නොවන අභිරුචි මෙවලම්වල ප්රතිදානය සම්පීඩනය කිරීමට ඔබට ඔබේම පෙරහන් එක් කළ හැක. ### පෙරහන් යෝජනා ක්රමය (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 Traceback පෙරහන ```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 # පරිශීලක මට්ටම /.rtk/filters/my-filter.json # ව්යාපෘති මට්ටම ``` ආරම්භයේදී `open-sse/services/compression/engines/rtk/filterLoader.ts` තුළ ඇති `loadRtkFilters()` හරහා පෙරහන් ස්වයංක්රීයව පූරණය වේ. පූරකය පහත ස්ථානවලින් පෙරහන් සොයාගනී: - ගොඩනඟා ඇති නාමාවලිය: `open-sse/services/compression/engines/rtk/filters/` - පරිශීලක නාමාවලිය: `~/.omniroute/rtk/filters/` - ව්යාපෘති නාමාවලිය: `/.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 මඟින් සම්බන්ධ කර ඇත) ``` ### අමු ප්රතිදාන ගබඩා කිරීම සක්රීය කිරීම **එක් එක් ඉල්ලීම සඳහා** (combo වින්යාසය තුළ): ```json { "compression": { "engine": "rtk", "intensity": "aggressive", "rawOutput": { "enabled": true, "maxBytes": 1048576 // 1MB cap } } } ``` **පෙරනිමිය**: `rawOutput.enabled: false` (ගබඩා ඉඩ ඉතිරි කරයි). ### ගබඩා පිරිවැය | එක් ඉල්ලීමකට | 1MB සීමාව | 10MB සීමාව | | -------------------------- | ------------ | ------------- | | සාමාන්ය සම්පීඩිත ප්රතිදානය | ~5KB | ~5KB | | ගබඩා කළ අමු ප්රතිදානය | ~50-500KB | ~500KB-5MB | | දිනකට ඉල්ලීම් 1000ක් සමඟ | 50-500MB/දින | 500MB-5GB/දින | > **නිර්දේශය**: අමු ප්රතිදානය සැමවිටම සක්රීයව තැබීම වෙනුවට, **දෝෂහරණ සැසි** හෝ **නියැදි විගණනය** සඳහා පමණක් සක්රීය කරන්න. ### මුල් ප්රතිදානය ප්රතිසාධනය කිරීම ```ts import { readRtkRawOutput } from "omniroute/compression/engines/rtk/rawOutput"; const raw = readRtkRawOutput(pointerId); // pointerId from compression stats 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. සෑම පෙරහනක්ම පූරණය වී schema සත්යාපනය සමත් වේ 2. සෑම `tests[]` ප්රවේශයක්ම අපේක්ෂිත ප්රතිදානය නිපදවයි 3. `minimal` තීව්රතාව කිසිදු මෙහෙයුමක් සිදු නොකරයි (මුල් අගය රැකගෙන ව්යුහාත්මක පෙරහන් පමණක් යොදයි) 4. `aggressive` තීව්රතාව දෝෂ, පරීක්ෂණ අසමත්වීම් සහ stack traces රැකගනී 5. සම්පීඩිත ප්රතිදානය කිසිවිටෙකත් මුල් ආදානයට වඩා විශාල නොවේ - මූලාශ්රය: `open-sse/services/compression/engines/rtk/` (ගොනු 63ක්, ~70KB) - **පෙරහනක වෙනසක් ඒකාබද්ධ කිරීමට පෙර** — සෑම විටම පරීක්ෂණ සමත් වන බව තහවුරු කරන්න - **RTK engine උත්ශ්රේණිගත කිරීමෙන් පසු** — schema වෙනස් වී තිබිය හැක - **අධීක්ෂණයේදී වරින් වර** — පරීක්ෂණ fixturesවල අපගමනයෙන් ආරක්ෂා කරයි - **නව tool/command පවුලක් එක් කරන විට** — නව පෙරහන ක්රියා කරන බව සනාථ කරයි --- ## මෙයද බලන්න - [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)