pjandro/OmniRoute
1
0
Fork 0
mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-20 22:02:19 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
d715190bb03da80da933d562129d8a76998eaa4d
OmniRoute/docs/i18n/or/docs/compression/RTK_COMPRESSION.md
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

60 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 · 🇮🇳 ml · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 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%)। OmniRoute Caveman ଇନପୁଟ୍ କମ୍ପ୍ରେସନ୍ ସହିତ ଷ୍ଟାକ୍ଡ ସଞ୍ଚୟ ଗଣନା ପାଇଁ ସେହି ଅପ୍ଷ୍ଟ୍ରିମ୍ ହାରାହାରିକୁ ବ୍ୟବହାର କରେ:

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 ହ୍ୟାଶ୍ ରହିଛି।

ଟ୍ରଷ୍ଟ ଫାଇଲ୍ ଉଦାହରଣ:

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

ହ୍ୟାଶ୍ଗୁଡ଼ିକ ପୃଥକ: filtersSha256 .rtk/filters.jsonକୁ ବିଶ୍ୱାସ କରେ, ଯେତେବେଳେ filtersTomlSha256 .rtk/filters.tomlକୁ ବିଶ୍ୱାସ କରେ। ଯେକୌଣସି ଫାଇଲ୍ ସମ୍ପାଦନା କଲେ କେବଳ ତାହାର ନିଜସ୍ୱ ଟ୍ରଷ୍ଟ ଏଣ୍ଟ୍ରି ଅବୈଧ ହୁଏ। ଗ୍ଲୋବାଲ୍ ଫାଇଲ୍ଗୁଡ଼ିକ ପ୍ରଶାସକଙ୍କ ଦ୍ୱାରା ଇନ୍ଷ୍ଟଲ୍ କରାଯାଏ ଏବଂ ପୂର୍ବରୁ ଥିବା ଗ୍ଲୋବାଲ୍-ଫିଲ୍ଟର୍ ଟ୍ରଷ୍ଟ ଆଚରଣ ବ୍ୟବହାର କରେ।

କଷ୍ଟମ୍ ଫିଲ୍ଟର୍ ଏକ ଫିଲ୍ଟର୍ ଅବଜେକ୍ଟ କିମ୍ବା ଫିଲ୍ଟର୍ ଅବଜେକ୍ଟଗୁଡ଼ିକର ଏକ ଆରେ ହୋଇପାରେ। ଅବୈଧ କଷ୍ଟମ୍ ଫିଲ୍ଟର୍ଗୁଡ଼ିକୁ ଏଡ଼ାଇ ଦିଆଯାଏ ଏବଂ /api/context/rtk/filters ଡାଇଗ୍ନୋଷ୍ଟିକ୍ସ ଦ୍ୱାରା ରିପୋର୍ଟ କରାଯାଏ। ଅବୈଧ ବିଲ୍ଟ-ଇନ୍ ଫିଲ୍ଟର୍ଗୁଡ଼ିକ ତୁରନ୍ତ ବିଫଳ ହୁଅନ୍ତି।

RTK TOML ସ୍କିମା v1 ସୁସଙ୍ଗତତା

OmniRoute, RTK TOML ସ୍କିମା 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.<filter>]] ଇନଲାଇନ୍ ପରୀକ୍ଷଣ। ଅଜଣା ଫିଲ୍ଡ, ଅବୈଧ କିମ୍ବା ଅସୁରକ୍ଷିତ ରେଗୁଲାର୍ ଏକ୍ସପ୍ରେସନ୍, ଏକକାଳୀନ strip/keep ନିୟମ, 1 MiB ଠାରୁ ବଡ଼ ଫାଇଲ୍, ଏବଂ ଅଜଣା ଫିଲ୍ଟର୍ର ସନ୍ଦର୍ଭଗୁଡ଼ିକୁ ପ୍ରତ୍ୟାଖ୍ୟାନ କରାଯାଏ। ଯେଉଁ ଫାଇଲ୍ର ଇନଲାଇନ୍ ପରୀକ୍ଷଣ ବିଫଳ ହୁଏ, ତାହାକୁ ଯାଞ୍ଚ ପାଇଁ ବୈଧତା ପରୀକ୍ଷା କରାଯାଇପାରେ, କିନ୍ତୁ ଇନଷ୍ଟଲ୍ କିମ୍ବା ଲୋଡ୍ କରାଯାଇପାରେ ନାହିଁ। କଷ୍ଟମ୍ ଫାଇଲ୍ ଲୋଡ୍ ବିଫଳତାଗୁଡ଼ିକ fail-open ହୋଇ ରହେ: ଅବୈଧ ଫାଇଲ୍ଟିକୁ ଛାଡ଼ି ଦିଆଯାଏ ଏବଂ ଅବଶିଷ୍ଟ ଫିଲ୍ଟର୍ଗୁଡ଼ିକ କାର୍ଯ୍ୟ କରିବା ଜାରି ରଖେ।

କ୍ଲାଏଣ୍ଟ ଟୁଲ୍ ଆଉଟପୁଟ୍କୁ ପୂର୍ବରୁ କ୍ୟାପ୍ଚର୍ କରିସାରିବା ପରେ OmniRoute ଏହାକୁ ଗ୍ରହଣ କରେ, ତେଣୁ filter_stderr = true ପ୍ରୋସେସ୍ କ୍ୟାପ୍ଚର୍କୁ ପରିବର୍ତ୍ତନ କରିପାରିବ ନାହିଁ। ଫିଲ୍ଡଟିକୁ no-op ଭାବେ ଗ୍ରହଣ କରାଯାଏ ଏବଂ ବୈଧତା ଯାଞ୍ଚ ଏକ ସତର୍କବାର୍ତ୍ତା ଫେରାଏ। ଏହାକୁ ଉଦ୍ଦେଶ୍ୟମୂଳକ ଭାବେ RTK TOML ସ୍କିମା v1 ସୁସଙ୍ଗତତା ରୂପେ ବର୍ଣ୍ଣନା କରାଯାଇଛି, RTK ଏକ୍ସିକ୍ୟୁଟେବଲ୍, shell hooks, Rust କମାଣ୍ଡ ଇମ୍ପ୍ଲିମେଣ୍ଟେସନ୍ କିମ୍ବା ଏହାର trust-store ଲେଆଉଟ୍ ସହିତ ପୂର୍ଣ୍ଣ ସୁସଙ୍ଗତତା ଭାବେ ନୁହେଁ।

ଡ୍ୟାସ୍ବୋର୍ଡର ଉନ୍ନତ RTK ଭ୍ୟୁ ପେଷ୍ଟ କିମ୍ବା ଅପଲୋଡ୍ କରାଯାଇଥିବା TOML ଗ୍ରହଣ କରେ। ବୈଧତା ଯାଞ୍ଚ କେବଳ-ପଠନୀୟ। ଇନଷ୍ଟଲେସନ୍ ପ୍ରତିବନ୍ଧକ ଅନୁମତି ସହିତ ପରମାଣବିକ ଭାବେ DATA_DIR/rtk/filters.toml ଲେଖେ ଏବଂ ପୁନଃଚାଳନ ବିନା ଲାଇଭ୍ ଫିଲ୍ଟର୍ କ୍ୟାଟାଲଗ୍କୁ ସତେଜ କରେ। ଏକ ବିଦ୍ୟମାନ ଫାଇଲ୍କୁ ବଦଳାଇବା ପାଇଁ ସ୍ପଷ୍ଟ overwrite ନିଶ୍ଚିତକରଣ ଆବଶ୍ୟକ ଏବଂ ପ୍ରଥମେ DATA_DIR/rtk/filters.toml.bak ସୃଷ୍ଟି କରାଯାଏ।

ଫିଲ୍ଟର୍ DSL

ଫିଲ୍ଟର୍ଗୁଡ଼ିକ କମ୍ପ୍ରେସନ୍ ନିୟମ ଫର୍ମାଟ୍ରେ ବର୍ଣ୍ଣିତ JSON ସ୍କିମା ବ୍ୟବହାର କରନ୍ତି। ରନ୍ଟାଇମ୍ ଏହି ପର୍ଯ୍ୟାୟଗୁଡ଼ିକୁ କ୍ରମାନୁସାରେ ପ୍ରୟୋଗ କରେ:

stripAnsi -> filterStderr -> replace -> matchOutput -> ଧାଡ଼ିଗୁଡ଼ିକୁ ଛାଡ଼ନ୍ତୁ/ଅନ୍ତର୍ଭୁକ୍ତ କରନ୍ତୁ
  -> truncateLineAt -> head/tail/maxLines -> onEmpty

ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ଫିଲ୍ଡଗୁଡ଼ିକ:

ଫିଲ୍ଡ ଉଦ୍ଦେଶ୍ୟ
rules.stripAnsi ମେଳ କରିବା ପୂର୍ବରୁ ଟର୍ମିନାଲ୍ ରଙ୍ଗ/ନିୟନ୍ତ୍ରଣ କ୍ରମଗୁଡ଼ିକୁ ଅପସାରଣ କରେ
rules.filterStderr ମେଳ/ଫିଲ୍ଟର୍ କରିବା ପୂର୍ବରୁ ସାଧାରଣ stderr ଉପସର୍ଗଗୁଡ଼ିକୁ ସ୍ୱାଭାବିକ କରେ
rules.replace କ୍ରମବଦ୍ଧ regex ପ୍ରତିସ୍ଥାପନଗୁଡ଼ିକୁ ପ୍ରୟୋଗ କରେ
rules.matchOutput ଆଉଟପୁଟ୍ ଏକ ଜଣାଶୁଣା ସର୍ତ୍ତ ସହିତ ମେଳ ହେଲେ ଏକ ସଂକ୍ଷିପ୍ତ ସାରାଂଶ ଫେରାଏ
rules.matchOutput[].unless ତ୍ରୁଟି/ବିଫଳତା ପ୍ୟାଟର୍ନ ଉପସ୍ଥିତ ଥିଲେ ସର୍ଟକଟ୍ଟିକୁ ଏଡ଼ାଇ ଦିଏ
rules.dropPatterns ଅନାବଶ୍ୟକ କୋଳାହଳପୂର୍ଣ୍ଣ ଧାଡ଼ିଗୁଡ଼ିକୁ ଅପସାରଣ କରେ
rules.includePatterns କାର୍ଯ୍ୟୋପଯୋଗୀ ଧାଡ଼ିଗୁଡ଼ିକୁ ପ୍ରାଥମିକତା ଦିଏ
rules.collapsePatterns ପୁନରାବୃତ୍ତ ମେଳ ଖାଉଥିବା ଧାଡ଼ିଗୁଡ଼ିକୁ ସଂକୁଚିତ କରେ
rules.deduplicate ପ୍ରତି-ଫିଲ୍ଟର୍ ଅପ୍ଟ-ଇନ୍: କ୍ରମାଗତ ନକଲ ଧାଡ଼ିଗୁଡ଼ିକୁ ସଂକୁଚିତ କରେ
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 ନୁହେଁ) ବ୍ୟବହାର କରେ, ଯାହାଦ୍ୱାରା string, template ଏବଂ regex ଲିଟେରାଲ୍ଗୁଡ଼ିକୁ କେବେ ମନ୍ତବ୍ୟ ବୋଲି ଭୁଲ୍ କରାଯାଏ ନାହିଁ; ଏବଂ JSX ଚିହ୍ନଟ ହେଲେ ଏହା ସମ୍ପୂର୍ଣ୍ଣ ଭାବେ ପ୍ରକ୍ରିୟାରୁ ବାହାରିଯାଏ (ଯାହାଦ୍ୱାରା JSX ଏକ୍ସପ୍ରେସନ୍-କଣ୍ଟେନର୍ ମନ୍ତବ୍ୟଗୁଡ଼ିକ କେବେ ମଧ୍ୟ ବିକୃତ ହୁଏ ନାହିଁ)। ମନ୍ତବ୍ୟ ଅପସାରଣ ବର୍ତ୍ତମାନ କେବଳ JavaScript ଏବଂ TypeScript ପାଇଁ ପ୍ରଯୁଜ୍ୟ — ଷ୍ଟ୍ରିପର୍ର CodeLanguage ସେଟ୍ରେ ଥିବା ଅନ୍ୟ ଭାଷାଗୁଡ଼ିକ (Python, Rust, Go, Ruby, Java) ପାଇଁ ଖାଲି ଲାଇନ୍ ଏବଂ whitespace ସଂକୋଚନ ଅଛି, କିନ୍ତୁ ମନ୍ତବ୍ୟ ଅପସାରଣ ନାହିଁ। ଅପସାରିତ-ବ୍ଲକ୍ ରନ୍କୁ 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 ମାଧ୍ୟମରେ ଉପଲବ୍ଧ।

{
  "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 ଫିଲ୍ଟର୍ ID ବ୍ୟବହାର କରେ, ଉଦାହରଣ ସ୍ୱରୂପ 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 ସ୍କିମା 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-କୀ ନୀତି ଆବଶ୍ୟକ।

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 key, Slack token, AWS access key, ଏବଂ assignment-ଶୈଳୀର token=..., secret=..., password=... ମୂଲ୍ୟ ଅନ୍ତର୍ଭୁକ୍ତ। ଆନାଲିଟିକ୍ସ କେବଳ pointer id, ଆକାର ଏବଂ hash metadata ସଂରକ୍ଷଣ କରେ।

ଯାଞ୍ଚ ଗେଟ୍

କେନ୍ଦ୍ରିତ ଯାଞ୍ଚ ଗେଟ୍ ବାହ୍ୟ କମାଣ୍ଡକୁ shell ମାଧ୍ୟମରେ ଚଲାଇବା ବିନା ଅନ୍ତର୍ନିର୍ମିତ inline filter ପରୀକ୍ଷାଗୁଡ଼ିକ ଚଲାଏ:

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 ବିସ୍ତାର କରିବା

  1. ଗୋଟିଏ filter JSON ଫାଇଲ୍ ଯୋଡ଼ନ୍ତୁ କିମ୍ବା ଅଦ୍ୟତନ କରନ୍ତୁ।
  2. ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ଆଚରଣକୁ ପ୍ରମାଣିତ କରୁଥିବା ଅତି କମରେ ଗୋଟିଏ tests[] ନମୁନା ଅନ୍ତର୍ଭୁକ୍ତ କରନ୍ତୁ।
  3. ନୂଆ command family ପାଇଁ tests/unit/compression/fixtures/rtk/ ଅଧୀନରେ ଗୋଟିଏ fixture ଯୋଡ଼ନ୍ତୁ।
  4. ଏକ ନୂଆ output class ପ୍ରଚଳନ କରିବା ସମୟରେ command detection coverage ଯୋଡ଼ନ୍ତୁ।
  5. ଯାଞ୍ଚ ଏବଂ ବ୍ୟାପକ RTK ଗେଟ୍ଗୁଡ଼ିକ ଚଲାନ୍ତୁ।
  6. filterଟି ଯଦି project-local ହୁଏ, ତେବେ .rtk/filters.json commit କରନ୍ତୁ ଏବଂ କେବଳ ସମୀକ୍ଷା ପରେ .rtk/trust.json refresh କରନ୍ତୁ।

ତୀବ୍ରତା ସ୍ତରଗୁଡ଼ିକ (v3.8.16+)

RTK 3ଟି ତୀବ୍ରତା ସ୍ତର ସମର୍ଥନ କରେ, ଯାହା compression aggressiveness ଏବଂ ସୁରକ୍ଷା ମଧ୍ୟରେ ସମନ୍ୱୟ ରଖେ। ଇଞ୍ଜିନ୍ configରେ config.intensity ମାଧ୍ୟମରେ ସ୍ତରଟି ସେଟ୍ କରାଯାଏ।

3ଟି ସ୍ତର

ସ୍ତର କର୍ତ୍ତନ ସୀମା Token ସଞ୍ଚୟ ବିପଦ ଏଥିପାଇଁ ସର୍ବୋତ୍ତମ
minimal ପ୍ରତି ବିଭାଗରେ 24ଟି ଧାଡ଼ି ~20-40% ଅତ୍ୟନ୍ତ କମ୍ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ context ସହିତ production
standard (ଡିଫଲ୍ଟ) ପ୍ରତି ବିଭାଗରେ 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
ତ୍ରୁଟି / stack trace ✅ ସଂରକ୍ଷିତ ✅ ସଂରକ୍ଷିତ ✅ ସଂରକ୍ଷିତ
ପରୀକ୍ଷା ବିଫଳତା ✅ ସଂରକ୍ଷିତ ✅ ସଂରକ୍ଷିତ ✅ ସଂରକ୍ଷିତ
Build ତ୍ରୁଟି ✅ ସଂରକ୍ଷିତ ✅ ସଂରକ୍ଷିତ ✅ ସଂରକ୍ଷିତ
ପରୀକ୍ଷାରେ ସଫଳତା (ବିସ୍ତୃତ) ✅ ସଂରକ୍ଷିତ 🟡 ସଙ୍କୁଚିତ 🟡 ସଙ୍କୁଚିତ
ନିୟମିତ ଆଉଟପୁଟ୍ (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"
  }
}

ପ୍ରୋଗ୍ରାମାଟିକ୍ ଭାବେ:

rtkEngine (@omniroute/open-sse/services/compression/engines/rtk) ଗୋଟିଏ CompressionEngine ଅଟେ ଏବଂ ଏଥିରେ କୌଣସି updateConfig method ନାହିଁ। ତାହା ପରିବର୍ତ୍ତେ registry helper ମାଧ୍ୟମରେ ଇଞ୍ଜିନ୍ର 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("ଆକ୍ରାମକ ତୀବ୍ରତାରେ filterଗୁଡ଼ିକ ବିଫଳ ହେଲା");
}

କଷ୍ଟମ୍ ଫିଲ୍ଟର୍ ବିକାଶ (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 Traceback ଫିଲ୍ଟର୍

{
  "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: ଫିଲ୍ଟର୍ "my-filter" ବୈଧତା ଯାଞ୍ଚରେ ବିଫଳ ହେଲା:
  - rules.replace.0.pattern: ଅବୈଧ regex
  - match.commands: ଖାଲି ହେବା ଉଚିତ୍ ନୁହେଁ

ସମସ୍ତ ଇନ୍ଷ୍ଟଲ୍ ହୋଇଥିବା ଫିଲ୍ଟର୍କୁ ଯାଞ୍ଚ କରିବା ପାଇଁ runRtkFilterTests() କଲ୍ କରନ୍ତୁ, ଯାହା open-sse/services/compression/engines/rtk/verify.ts ରୁ ଏକ୍ସପୋର୍ଟ କରାଯାଇଛି।

ସର୍ବୋତ୍ତମ ଅଭ୍ୟାସଗୁଡ଼ିକ

  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 ବିନ୍ୟାସରେ):

{
  "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/ଦିନ 500MB-5GB/ଦିନ

ସୁପାରିସ: ମୂଳ ଆଉଟପୁଟ୍କୁ ସବୁବେଳେ ସକ୍ଷମ ରଖିବା ପରିବର୍ତ୍ତେ କେବଳ ଡିବଗିଂ ସେସନ୍ କିମ୍ବା ନମୁନାଭିତ୍ତିକ ଅଡିଟିଂ ପାଇଁ ସକ୍ଷମ କରନ୍ତୁ।

ମୂଳ ଆଉଟପୁଟ୍ ପୁନରୁଦ୍ଧାର କରିବା

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

const raw = readRtkRawOutput(pointerId); // compression statsରୁ 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}"`
      );
    });
}

ଏହା ଯାହା ବୈଧ କରେ:

  1. ପ୍ରତ୍ୟେକ ଫିଲ୍ଟର୍ ଲୋଡ୍ ହୁଏ ଏବଂ ସ୍କିମା ବୈଧତା ଯାଞ୍ଚରେ ଉତ୍ତୀର୍ଣ୍ଣ ହୁଏ
  2. ପ୍ରତ୍ୟେକ tests[] ଏଣ୍ଟ୍ରି ଆଶାକରା ଆଉଟପୁଟ୍ ଉତ୍ପନ୍ନ କରେ
  3. minimal ତୀବ୍ରତା ଏକ no-op ଅଟେ (ମୂଳକୁ ସଂରକ୍ଷିତ ରଖେ, କେବଳ ଗଠନାତ୍ମକ ଫିଲ୍ଟର୍ ପ୍ରୟୋଗ କରେ)
  4. aggressive ତୀବ୍ରତା ତ୍ରୁଟି, ପରୀକ୍ଷା ବିଫଳତା ଏବଂ ଷ୍ଟାକ୍ ଟ୍ରେସ୍ଗୁଡ଼ିକୁ ସଂରକ୍ଷିତ ରଖେ
  5. ସଂକୁଚିତ ଆଉଟପୁଟ୍ କେବେବି ମୂଳ ଇନପୁଟ୍ଠାରୁ ବଡ଼ ହୁଏ ନାହିଁ

  • ଉତ୍ସ: 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)
Reference in New Issue View Git Blame Copy Permalink