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

65 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 · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 ml · 🇮🇳 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 ಅನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ.
.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 ಎಕ್ಸಿಕ್ಯೂಟಬಲ್, ಶೆಲ್ ಹುಕ್ಗಳು, Rust ಕಮಾಂಡ್ ಅನುಷ್ಠಾನಗಳು ಅಥವಾ ಅದರ ಟ್ರಸ್ಟ್-ಸ್ಟೋರ್ ವಿನ್ಯಾಸದೊಂದಿಗೆ ಸಂಪೂರ್ಣ ಹೊಂದಾಣಿಕೆ ಎಂದು ಅಲ್ಲ.

ಡ್ಯಾಶ್ಬೋರ್ಡ್ನ ಸುಧಾರಿತ RTK ವೀಕ್ಷಣೆಯು ಅಂಟಿಸಿದ ಅಥವಾ ಅಪ್ಲೋಡ್ ಮಾಡಿದ TOML ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಮೌಲ್ಯೀಕರಣವು ಓದಲು ಮಾತ್ರ. ಸ್ಥಾಪನೆಯು ನಿರ್ಬಂಧಿತ ಅನುಮತಿಗಳೊಂದಿಗೆ DATA_DIR/rtk/filters.toml ಅನ್ನು ಅಟಾಮಿಕ್ ರೀತಿಯಲ್ಲಿ ಬರೆಯುತ್ತದೆ ಮತ್ತು ಮರುಪ್ರಾರಂಭವಿಲ್ಲದೆ ಲೈವ್ ಫಿಲ್ಟರ್ ಕ್ಯಾಟಲಾಗ್ ಅನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಫೈಲ್ ಅನ್ನು ಬದಲಿಸಲು ಸ್ಪಷ್ಟವಾದ overwrite ದೃಢೀಕರಣದ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಮೊದಲು DATA_DIR/rtk/filters.toml.bak ಅನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.

ಫಿಲ್ಟರ್ DSL

ಫಿಲ್ಟರ್ಗಳು Compression Rules Format ನಲ್ಲಿ ವಿವರಿಸಲಾದ JSON ಸ್ಕೀಮಾವನ್ನು ಬಳಸುತ್ತವೆ. ರನ್ಟೈಮ್ ಈ ಹಂತಗಳನ್ನು ಕ್ರಮವಾಗಿ ಅನ್ವಯಿಸುತ್ತದೆ:

stripAnsi -> filterStderr -> replace -> matchOutput -> ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಿ/ಸೇರಿಸಿ
  -> 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[]`	ಪರಿಶೀಲನಾ ಗೇಟ್ ಬಳಸುವ ಇನ್ಲೈನ್ ಮಾದರಿಗಳು

ಅಂತರ್ನಿರ್ಮಿತ ಫಿಲ್ಟರ್ಗಳು ಇನ್ಲೈನ್ 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 ಆಗಿದ್ದಾಗ, RTK JavaScript ಮತ್ತು TypeScript ಬೇಲಿಯುಕ್ತ ಬ್ಲಾಕ್ಗಳಿಂದ ಕಾಮೆಂಟ್ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಐತಿಹಾಸಿಕವಾಗಿ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಓದಲಾಗುತ್ತಿತ್ತು, ಆದರೆ ಎಂದಿಗೂ ಅನ್ವಯಿಸಲಾಗುತ್ತಿರಲಿಲ್ಲ; ಹೀಗಾಗಿ ಸೂಚನೆಯಿಲ್ಲದೆ ಪ್ರೊಡಕ್ಷನ್ ಬದಲಾವಣೆಯಾಗುವುದನ್ನು ತಪ್ಪಿಸಲು ಡೀಫಾಲ್ಟ್ ಅನ್ನು "ಉಳಿಸಿಕೊಳ್ಳಿ" ಎಂದೇ ಇರಿಸಲಾಗಿದೆ.
preserveDocstrings (ಡೀಫಾಲ್ಟ್ true) — ಕಾಮೆಂಟ್ಗಳನ್ನು ತೆಗೆದುಹಾಕುವಾಗ, JSDoc//** … */ ಬ್ಲಾಕ್ ಕಾಮೆಂಟ್ಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ (ಅವು ಬಳಸುವ ಬೈಟ್ಗಳಿಗಿಂತ ಹೆಚ್ಚು ಮೌಲ್ಯಯುತವಾದ API ದಸ್ತಾವೇಜನ್ನು ಹೊಂದಿರುತ್ತವೆ). ಅವನ್ನೂ ತೆಗೆದುಹಾಕಲು ಇದನ್ನು false ಗೆ ಹೊಂದಿಸಿ.

ಕಾಮೆಂಟ್ ತೆಗೆದುಹಾಕುವಿಕೆಯನ್ನು open-sse/services/compression/engines/rtk/codeStripper.ts ನಲ್ಲಿ ಅನುಷ್ಠಾನಗೊಳಿಸಲಾಗಿದೆ. ಇದು TypeScript ಪಾರ್ಸರ್ ಅನ್ನು (ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್ಪ್ರೆಷನ್ ಅಲ್ಲ) ಬಳಸುತ್ತದೆ; ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್, ಟೆಂಪ್ಲೇಟ್ ಮತ್ತು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್ಪ್ರೆಷನ್ ಲಿಟರಲ್ಗಳನ್ನು ಎಂದಿಗೂ ಕಾಮೆಂಟ್ಗಳೆಂದು ತಪ್ಪಾಗಿ ಗುರುತಿಸಲಾಗುವುದಿಲ್ಲ. 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/, ವೆಂಡರ್ ಮಾಡಲಾದ ಕೋಡೆಕ್ 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" ಅಡಿಯಲ್ಲಿ (src/lib/db/compression.ts) ಒಂದೇ JSON ಮೌಲ್ಯವಾಗಿ ಉಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಓದುವಾಗ 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-ಕೀ ನೀತಿ ಅಗತ್ಯವಿದೆ.

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 ಟೋಕನ್ಗಳು, API ಕೀಗಳು, Slack ಟೋಕನ್ಗಳು, AWS ಪ್ರವೇಶ ಕೀಗಳು ಮತ್ತು ಅಸೈನ್ಮೆಂಟ್-ಶೈಲಿಯ token=..., secret=..., password=... ಮೌಲ್ಯಗಳು ಸೇರಿವೆ. ಅನಾಲಿಟಿಕ್ಸ್ ಪಾಯಿಂಟರ್ ಐಡಿ, ಗಾತ್ರ ಮತ್ತು ಹ್ಯಾಶ್ ಮೆಟಾಡೇಟಾವನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸುತ್ತದೆ.

ಪರಿಶೀಲನಾ ಗೇಟ್

ಕೇಂದ್ರೀಕೃತ ಪರಿಶೀಲನಾ ಗೇಟ್ ಬಾಹ್ಯ ಕಮಾಂಡ್ಗಳನ್ನು shell ಮೂಲಕ ಚಲಾಯಿಸದೆ ಅಂತರ್ನಿರ್ಮಿತ inline ಫಿಲ್ಟರ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಚಲಾಯಿಸುತ್ತದೆ:

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

ಬಿಡುಗಡೆಗೂ ಮೊದಲು ವಿಸ್ತೃತ ಸಂಕೋಚನ ಗೇಟ್ ಅನ್ನು ಚಲಾಯಿಸಿ:

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 ವಿಸ್ತರಣೆ

ಫಿಲ್ಟರ್ JSON ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಿ ಅಥವಾ ನವೀಕರಿಸಿ.
ಪ್ರಮುಖ ವರ್ತನೆಯನ್ನು ಸಾಬೀತುಪಡಿಸುವ ಕನಿಷ್ಠ ಒಂದು tests[] ಮಾದರಿಯನ್ನು ಸೇರಿಸಿ.
ಹೊಸ ಕಮಾಂಡ್ ಕುಟುಂಬಗಳಿಗಾಗಿ tests/unit/compression/fixtures/rtk/ ಅಡಿಯಲ್ಲಿ fixture ಒಂದನ್ನು ಸೇರಿಸಿ.
ಹೊಸ ಔಟ್ಪುಟ್ ವರ್ಗವನ್ನು ಪರಿಚಯಿಸುವಾಗ ಕಮಾಂಡ್ ಪತ್ತೆ ವ್ಯಾಪ್ತಿಯನ್ನು ಸೇರಿಸಿ.
ಪರಿಶೀಲನಾ ಮತ್ತು ವಿಸ್ತೃತ RTK ಗೇಟ್ಗಳನ್ನು ಚಲಾಯಿಸಿ.
ಫಿಲ್ಟರ್ ಪ್ರಾಜೆಕ್ಟ್ಗೆ ಸ್ಥಳೀಯವಾಗಿದ್ದರೆ, ಪರಿಶೀಲನೆಯ ನಂತರ ಮಾತ್ರ .rtk/filters.json ಅನ್ನು commit ಮಾಡಿ ಮತ್ತು .rtk/trust.json ಅನ್ನು ರಿಫ್ರೆಶ್ ಮಾಡಿ.

ತೀವ್ರತೆಯ ಮಟ್ಟಗಳು (v3.8.16+)

RTK ಸಂಕೋಚನದ ಆಕ್ರಮಣಶೀಲತೆ ಮತ್ತು ಸುರಕ್ಷತೆ ನಡುವೆ ಸಮತೋಲನ ಸಾಧಿಸುವ 3 ತೀವ್ರತೆಯ ಮಟ್ಟಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಎಂಜಿನ್ config ನಲ್ಲಿ config.intensity ಮೂಲಕ ಮಟ್ಟವನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತದೆ.

3 ಮಟ್ಟಗಳು

ಮಟ್ಟ	ಮೊಟಕುಗೊಳಿಸುವಿಕೆಯ ಮಿತಿ	ಟೋಕನ್ ಉಳಿತಾಯ	ಅಪಾಯ	ಇದಕ್ಕೆ ಅತ್ಯುತ್ತಮ
`minimal`	ಪ್ರತಿ ವಿಭಾಗಕ್ಕೆ 24 ಸಾಲುಗಳು	~20-40%	ಅತ್ಯಂತ ಕಡಿಮೆ	ನಿರ್ಣಾಯಕ ಸಂದರ್ಭವಿರುವ ಪ್ರೊಡಕ್ಷನ್
`standard` (ಡೀಫಾಲ್ಟ್)	ಪ್ರತಿ ವಿಭಾಗಕ್ಕೆ 24 ಸಾಲುಗಳು	~50-70%	ಕಡಿಮೆ	ದೈನಂದಿನ ಕೋಡಿಂಗ್ ಸೆಷನ್ಗಳು
`aggressive`	ಪ್ರತಿ ವಿಭಾಗಕ್ಕೆ 16 ಸಾಲುಗಳು	~70-90%	ಮಧ್ಯಮ	ದೀರ್ಘ ಸೆಷನ್ಗಳು, ಗರಿಷ್ಠ ಉಳಿತಾಯ

ಮೊಟಕುಗೊಳಿಸುವಿಕೆ ಎಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ

ಮೊಟಕುಗೊಳಿಸುವಿಕೆಯ ಮಿತಿಯು 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ಗಳು	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	✅ ಉಳಿಸಲಾಗುತ್ತದೆ
ಪರೀಕ್ಷಾ ವೈಫಲ್ಯಗಳು	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	✅ ಉಳಿಸಲಾಗುತ್ತದೆ
ಬಿಲ್ಡ್ ದೋಷಗಳು	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	✅ ಉಳಿಸಲಾಗುತ್ತದೆ
ಪರೀಕ್ಷಾ ಯಶಸ್ಸುಗಳು (ವಿವರವಾದ)	✅ ಉಳಿಸಲಾಗುತ್ತದೆ	🟡 ಸಂಕುಚಿಸಲಾಗುತ್ತದೆ	🟡 ಸಂಕುಚಿಸಲಾಗುತ್ತದೆ
ವಾಡಿಕೆಯ ಔಟ್ಪುಟ್ (info ಲಾಗ್ಗಳು)	🟡 ಸಂಕುಚಿಸಲಾಗುತ್ತದೆ	🟡 ಸಂಕುಚಿಸಲಾಗುತ್ತದೆ	❌ ಕೈಬಿಡಲಾಗುತ್ತದೆ
ಪ್ರಗತಿ ಪಟ್ಟಿಗಳು	🟡 ಸಂಕುಚಿಸಲಾಗುತ್ತದೆ	❌ ಕೈಬಿಡಲಾಗುತ್ತದೆ	❌ ಕೈಬಿಡಲಾಗುತ್ತದೆ
ಬ್ಯಾನರ್ / ASCII ಕಲೆ	🟡 ಸಂಕುಚಿಸಲಾಗುತ್ತದೆ	❌ ಕೈಬಿಡಲಾಗುತ್ತದೆ	❌ ಕೈಬಿಡಲಾಗುತ್ತದೆ

ಸರಿಯಾದ ತೀವ್ರತೆಯನ್ನು ಆಯ್ಕೆಮಾಡುವುದು

                  ಸಂದರ್ಭವನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದು ವಿಪತ್ಕಾರಿಯೇ?
                  │
      ┌───────────┼───────────┐
      │           │           │
     ಹೌದು        ಇಲ್ಲ       ಖಚಿತವಿಲ್ಲ
      │           │           │
      ▼           │           │
   minimal        │           │
      │           │           │
      │           ▼           ▼
      │      ಥ್ರೂಪುಟ್ ಎಷ್ಟು   ಮೊದಲು `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 ವಿಧಾನವನ್ನು ಹೊಂದಿಲ್ಲ. ಬದಲಿಗೆ registry helper ಮೂಲಕ ಎಂಜಿನ್ನ config ಅನ್ನು ನವೀಕರಿಸಿ:

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

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

ಪರಿಣಾಮವನ್ನು ಪರಿಶೀಲಿಸುವುದು

ನೀವು ಆಯ್ಕೆಮಾಡಿದ ತೀವ್ರತೆಯಲ್ಲಿ ನಿಮ್ಮ ಫಿಲ್ಟರ್ ಸುರಕ್ಷಿತವಾಗಿದೆ ಎಂಬುದನ್ನು ದೃಢೀಕರಿಸಲು ಪರಿಶೀಲನಾ ಗೇಟ್ (ಕೆಳಗೆ ನೋಡಿ) ಬಳಸಿ:

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

const result = runRtkFilterTests({ intensity: "aggressive" });
if (!result.passed) {
  console.error("ಆಕ್ರಮಣಶೀಲ ತೀವ್ರತೆಯಲ್ಲಿ ಫಿಲ್ಟರ್ಗಳು ವಿಫಲವಾಗಿವೆ");
}

ಕಸ್ಟಮ್ ಫಿಲ್ಟರ್ ಅಭಿವೃದ್ಧಿ (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: ಫಿಲ್ಟರ್ "my-filter" ಮೌಲ್ಯಮಾಪನದಲ್ಲಿ ವಿಫಲವಾಗಿದೆ:
  - rules.replace.0.pattern: ಅಮಾನ್ಯ Regex
  - match.commands: ಖಾಲಿಯಾಗಿರಬಾರದು

ಸ್ಥಾಪಿಸಲಾದ ಎಲ್ಲ ಫಿಲ್ಟರ್ಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು, 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 ಮೂಲಕ ಲಿಂಕ್ ಮಾಡಲಾಗಿದೆ)

ಮೂಲ ಔಟ್ಪುಟ್ ಸಂಗ್ರಹಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು

ಪ್ರತಿ ವಿನಂತಿಗೆ (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/day	500MB-5GB/day

ಶಿಫಾರಸು: ಮೂಲ ಔಟ್ಪುಟ್ ಅನ್ನು ಯಾವಾಗಲೂ ಸಕ್ರಿಯವಾಗಿಡುವ ಬದಲು, ಡೀಬಗಿಂಗ್ ಸೆಷನ್ಗಳು ಅಥವಾ ಮಾದರಿ ಆಧಾರಿತ ಲೆಕ್ಕಪರಿಶೋಧನೆಗಾಗಿ ಮಾತ್ರ ಸಕ್ರಿಯಗೊಳಿಸಿ.

ಮೂಲವನ್ನು ಮರುಪಡೆಯುವುದು

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

const raw = readRtkRawOutput(pointerId); // compression stats ನಿಂದ pointerId
if (raw) {
  console.log("Original output:", raw);
}

ಸಂಕುಚನದ ನಂತರ pointerId ಅನ್ನು CompressionStats.rtkRawOutputPointers[] ನಲ್ಲಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ. ಫಂಕ್ಷನ್ ಸಿಗ್ನೇಚರ್ಗಾಗಿ 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 ತೀವ್ರತೆಯು ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆ ಮಾಡುವುದಿಲ್ಲ (ಮೂಲವನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ, ರಚನಾತ್ಮಕ ಫಿಲ್ಟರ್ಗಳನ್ನು ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ)
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)

65 KiB Raw Blame History Unescape Escape

RTK Compression (ಕನ್ನಡ)

ಇದು ಏನನ್ನು ಕಂಪ್ರೆಸ್ ಮಾಡುತ್ತದೆ

ಫಿಲ್ಟರ್ ರೆಸಲ್ಯೂಷನ್

RTK TOML ಸ್ಕೀಮಾ v1 ಹೊಂದಾಣಿಕೆ

ಫಿಲ್ಟರ್ DSL

ಸಾಲು ನಕಲು ನಿವಾರಣೆ (ಎರಡು ಪದರಗಳು)

ಸಾಲು ಗುಂಪುಗೊಳಿಸುವಿಕೆ (enableGrouping)

ಕೋಡ್ ಕಾಮೆಂಟ್ ತೆಗೆದುಹಾಕುವಿಕೆ (stripCodeComments / preserveDocstrings)

ಸಂರಚನೆ

API

ಕಚ್ಚಾ ಔಟ್ಪುಟ್ ಮರುಪಡೆಯುವಿಕೆ

ಪರಿಶೀಲನಾ ಗೇಟ್

RTK ವಿಸ್ತರಣೆ

ತೀವ್ರತೆಯ ಮಟ್ಟಗಳು (v3.8.16+)

3 ಮಟ್ಟಗಳು

ಮೊಟಕುಗೊಳಿಸುವಿಕೆ ಎಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ

ಯಾವುದು ಉಳಿಯುತ್ತದೆ ಮತ್ತು ಯಾವುದು ಕಡಿತಗೊಳ್ಳುತ್ತದೆ

ಸರಿಯಾದ ತೀವ್ರತೆಯನ್ನು ಆಯ್ಕೆಮಾಡುವುದು

ತೀವ್ರತೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು

ಪರಿಣಾಮವನ್ನು ಪರಿಶೀಲಿಸುವುದು

ಕಸ್ಟಮ್ ಫಿಲ್ಟರ್ ಅಭಿವೃದ್ಧಿ (v3.8.16+)

ಫಿಲ್ಟರ್ ಸ್ಕೀಮಾ (Zod)

ಉದಾಹರಣೆ: Python ಟ್ರೇಸ್ಬ್ಯಾಕ್ ಫಿಲ್ಟರ್

ಕಸ್ಟಮ್ ಫಿಲ್ಟರ್ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವುದು

ಮೌಲ್ಯಮಾಪನ

ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಮೂಲ ಔಟ್ಪುಟ್ ಮರುಪಡೆಯುವಿಕೆ ಮತ್ತು ಪರಿಶೀಲನಾ ಗೇಟ್

ಮೂಲ ಔಟ್ಪುಟ್ ಮರುಪಡೆಯುವಿಕೆ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

ಮೂಲ ಔಟ್ಪುಟ್ ಸಂಗ್ರಹಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವುದು

ಸಂಗ್ರಹಣಾ ವೆಚ್ಚ

ಮೂಲವನ್ನು ಮರುಪಡೆಯುವುದು

ಪರಿಶೀಲನಾ ಗೇಟ್

ಇದನ್ನೂ ನೋಡಿ

65 KiB

Raw Blame History

ಸಾಲು ಗುಂಪುಗೊಳಿಸುವಿಕೆ (`enableGrouping`)

ಕೋಡ್ ಕಾಮೆಂಟ್ ತೆಗೆದುಹಾಕುವಿಕೆ (`stripCodeComments` / `preserveDocstrings`)