pjandro/OmniRoute
1
0
Fork 0
mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-22 06:42:19 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
80e2ca7c392b345d759dca58e05c2b8944bb73fe
OmniRoute/docs/i18n/mr/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

710 lines
58 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 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) · 🇨🇿 [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) · 🇲🇾 [ms](../../../ms/docs/compression/RTK_COMPRESSION.md) · 🇲🇹 [mt](../../../mt/docs/compression/RTK_COMPRESSION.md) · 🇲🇲 [my](../../../my/docs/compression/RTK_COMPRESSION.md) · 🇳🇵 [ne](../../../ne/docs/compression/RTK_COMPRESSION.md) · 🇳🇱 [nl](../../../nl/docs/compression/RTK_COMPRESSION.md) · 🇳🇴 [no](../../../no/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [or](../../../or/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [pa](../../../pa/docs/compression/RTK_COMPRESSION.md) · 🇵🇭 [phi](../../../phi/docs/compression/RTK_COMPRESSION.md) · 🇵🇱 [pl](../../../pl/docs/compression/RTK_COMPRESSION.md) · 🇵🇹 [pt](../../../pt/docs/compression/RTK_COMPRESSION.md) · 🇧🇷 [pt-BR](../../../pt-BR/docs/compression/RTK_COMPRESSION.md) · 🇷🇴 [ro](../../../ro/docs/compression/RTK_COMPRESSION.md) · 🇷🇺 [ru](../../../ru/docs/compression/RTK_COMPRESSION.md) · 🇱🇰 [si](../../../si/docs/compression/RTK_COMPRESSION.md) · 🇸🇰 [sk](../../../sk/docs/compression/RTK_COMPRESSION.md) · 🇸🇮 [sl](../../../sl/docs/compression/RTK_COMPRESSION.md) · 🇷🇸 [sr](../../../sr/docs/compression/RTK_COMPRESSION.md) · 🇸🇪 [sv](../../../sv/docs/compression/RTK_COMPRESSION.md) · 🇰🇪 [sw](../../../sw/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [ta](../../../ta/docs/compression/RTK_COMPRESSION.md) · 🇮🇳 [te](../../../te/docs/compression/RTK_COMPRESSION.md) · 🇹🇭 [th](../../../th/docs/compression/RTK_COMPRESSION.md) · 🇹🇷 [tr](../../../tr/docs/compression/RTK_COMPRESSION.md) · 🇺🇦 [uk-UA](../../../uk-UA/docs/compression/RTK_COMPRESSION.md) · 🇵🇰 [ur](../../../ur/docs/compression/RTK_COMPRESSION.md) · 🇺🇿 [uz](../../../uz/docs/compression/RTK_COMPRESSION.md) · 🇻🇳 [vi](../../../vi/docs/compression/RTK_COMPRESSION.md) · 🇳🇬 [yo](../../../yo/docs/compression/RTK_COMPRESSION.md) · 🇨🇳 [zh-CN](../../../zh-CN/docs/compression/RTK_COMPRESSION.md) · 🇹🇼 [zh-TW](../../../zh-TW/docs/compression/RTK_COMPRESSION.md)
---
RTK कॉम्प्रेशन हे टर्मिनल आणि टूल आउटपुटसाठी OmniRoute चे कमांड-जागरूक कॉम्प्रेशन इंजिन आहे. हे
अशा कोडिंग-एजंट सत्रांसाठी डिझाइन केलेले आहे, ज्यामध्ये संदर्भाची बहुतांश वाढ चाचणी लॉग, बिल्ड आउटपुट,
पॅकेज मॅनेजरमधील अनावश्यक मजकूर, शेल ट्रान्सक्रिप्ट, Docker आउटपुट, git आउटपुट आणि स्टॅक ट्रेसमधून होते.
RTK थेट `defaultMode: "rtk"` सह किंवा स्टॅक केलेल्या पाइपलाइनमधील पहिली पायरी म्हणून चालू शकते, सामान्यतः:
```txt
rtk -> caveman
```
हा क्रम प्रथम गोंगाटयुक्त मशीन आउटपुट कॉम्प्रेस करतो आणि त्यानंतर उर्वरित मजकूर संक्षिप्त करण्याचे काम Caveman ला करू देतो.
अपस्ट्रीम RTK नुसार कमांड आउटपुटमध्ये `60-90%` बचत होते. त्याच्या README मधील नमुना सत्र
`~118,000` मानक टोकन्सवरून `~23,900` RTK टोकन्सपर्यंत कमी होते, म्हणजे `79.7%` बचत (`~80%`). Caveman इनपुट कॉम्प्रेशनसह स्टॅक केलेल्या बचतीची गणना करण्यासाठी OmniRoute
ही अपस्ट्रीम सरासरी वापरते:
```txt
RTK सरासरी: 80% बचत
Caveman इनपुट: 46% बचत
स्टॅक केलेले: 1 - (1 - 0.80) * (1 - 0.46) = 89.2% बचत
श्रेणी: 1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%
```
## ते काय कॉम्प्रेस करते
अंगभूत कॅटलॉगमध्ये सध्या या श्रेणींमधील 49 फिल्टर्स समाविष्ट आहेत:
| श्रेणी | उदाहरणे |
| --------- | ------------------------------------------------------------- |
| `git` | `git status`, `git branch`, `git diff`, `git log` |
| `test` | Vitest, Jest, Pytest, Playwright, Go चाचण्या, Cargo चाचण्या |
| `build` | TypeScript, ESLint, Biome, Prettier, Vite, Webpack, Turbo, Nx |
| `package` | `npm install`, `npm audit`, `pip`, `uv sync`, Poetry, Bundler |
| `shell` | `ls`, `find`, `grep`, सर्वसाधारण शेल लॉग |
| `docker` | `docker ps`, Docker लॉग |
| `infra` | Terraform, OpenTofu, `systemctl status` |
| `generic` | JSON आउटपुट, स्टॅक ट्रेस, सर्वसाधारण आउटपुट फॉलबॅक |
`open-sse/services/compression/engines/rtk/commandDetector.ts` मधील डिटेक्टर फिल्टर निवडीपूर्वी आउटपुटचे
वर्गीकरण करतो. एखादा कमांड वर्ग पुरेसा नसल्यास फिल्टर्स कमांड पॅटर्न किंवा आउटपुट रेगेक्सनुसारही जुळू शकतात.
## फिल्टर रिझोल्यूशन
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 स्कीमा v1 फिल्टर्सना OmniRoute JSON फिल्टर्सपेक्षा प्राधान्य दिले जाते. आयात केलेला कमांड-विशिष्ट
फिल्टर त्या व्याप्तीतील अधिक व्यापक फिल्टरला अधिलिखित करू शकेल यासाठी TOML
`match_command` एक्स्प्रेशन्स कमांड-प्रकार जुळणीपूर्वी तपासली जातात. फाइल स्वरूप काहीही असले, प्रकल्प
व्याप्तीला तरीही ग्लोबल व्याप्तीपेक्षा प्राधान्य दिले जाते.
प्रकल्प फिल्टर्सना जाणीवपूर्वक विश्वास-आधारित मर्यादा लागू केली आहे, कारण रेगेक्स फिल्टर्स एजंटना टूल आउटपुट
कसे दाखवले जाते ते बदलू शकतात. खालीलपैकी एक अट सत्य असल्यास प्रकल्प फिल्टर फाइल स्वीकारली जाते:
- `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 स्कीमा 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
फिल्टर्स [Compression Rules Format](./COMPRESSION_RULES_FORMAT.md) मध्ये वर्णन केलेली JSON स्कीमा वापरतात.
रनटाइम हे टप्पे पुढील क्रमाने लागू करते:
```txt
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 नाही), त्यामुळे स्ट्रिंग, टेम्पलेट आणि 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/`, आणि व्हेंडर केलेला कोडेक
> `headroom/gcf/` अंतर्गत आहे). येथे दस्तऐवजीकरण केलेल्या RTK फिल्टर पाइपलाइनशी त्याचा संबंध नाही.
## कॉन्फिगरेशन
जागतिक सेटिंग्ज `/api/settings/compression` द्वारे उपलब्ध आहेत. RTK-विशिष्ट सेटिंग्जदेखील
`/api/context/rtk/config` द्वारे उपलब्ध आहेत.
```json
{
"defaultMode": "stacked",
"autoTriggerMode": "stacked",
"autoTriggerTokens": 32000,
"stackedPipeline": [
{ "engine": "rtk", "intensity": "standard" },
{ "engine": "caveman", "intensity": "full" }
],
"rtkConfig": {
"enabled": true,
"intensity": "standard",
"applyToToolResults": true,
"applyToCodeBlocks": false,
"applyToAssistantMessages": false,
"enabledFilters": [],
"disabledFilters": [],
"maxLinesPerResult": 120,
"maxCharsPerResult": 12000,
"deduplicateThreshold": 3,
"customFiltersEnabled": true,
"trustProjectFilters": false,
"rawOutputRetention": "never",
"rawOutputMaxBytes": 1048576,
"enableGrouping": false,
"groupingThreshold": 3,
"stripCodeComments": false,
"preserveDocstrings": true
}
}
```
`enabledFilters` आणि `disabledFilters` फिल्टर आयडी वापरतात, उदाहरणार्थ `test-vitest` किंवा `git-diff`.
`rtkConfig` ची संपूर्ण रचना `open-sse/services/compression/types.ts` मधील `RtkConfig` / `DEFAULT_RTK_CONFIG` द्वारे परिभाषित केली आहे. संपूर्ण ऑब्जेक्ट SQLite मधील `key_value` तक्त्यात `namespace = "compression"`, `key = "rtkConfig"` अंतर्गत एकच JSON मूल्य म्हणून कायमस्वरूपी साठवला जातो (`src/lib/db/compression.ts`) आणि वाचताना `normalizeRtkConfig` द्वारे सामान्यीकृत केला जातो. त्यामुळे खालील प्रत्येक फील्ड — `enableGrouping`, `groupingThreshold`, `stripCodeComments` आणि `preserveDocstrings` यांसह — त्याच स्टोअरमधून दोन्ही दिशांनी जतन होते आणि रीस्टार्टनंतरही टिकून राहते.
| की | डीफॉल्ट | उद्देश |
| ---------------------- | ------- | -------------------------------------------------------------------------------------------- |
| `deduplicateThreshold` | `3` | संपूर्ण इंजिनसाठी: संक्षिप्त करण्यासाठी सलग समान ओळींची किमान संख्या (2–100 पर्यंत मर्यादित) |
| `enableGrouping` | `false` | पर्यायी: जवळपास समतुल्य सलग ओळींचे समूह संक्षिप्त करा |
| `groupingThreshold` | `3` | समूह बनवण्यास चालना देणाऱ्या सलग समान ओळींच्या संचाची किमान संख्या |
| `stripCodeComments` | `false` | पर्यायी: कुंपणबद्ध कोड ब्लॉक्समधील टिप्पण्या काढा (`applyToCodeBlocks` आवश्यक) |
| `preserveDocstrings` | `true` | टिप्पण्या काढताना JSDoc/`/** … */` ब्लॉक्स कायम ठेवा |
## API
| मार्ग | पद्धत | उद्देश |
| ---------------------------------- | ----- | -------------------------------------------------------- |
| `/api/context/rtk/config` | GET | RTK कॉन्फिग वाचा |
| `/api/context/rtk/config` | PUT | RTK कॉन्फिग अद्ययावत करा |
| `/api/context/rtk/filters` | GET | फिल्टर कॅटलॉग आणि लोड निदानांची सूची दाखवा |
| `/api/context/rtk/import` | POST | RTK TOML स्कीमा v1 फाइल्स सत्यापित करा किंवा स्थापित करा |
| `/api/context/rtk/test` | POST | एका मजकूर पेलोडसाठी RTK संक्षेपणाचे पूर्वावलोकन करा |
| `/api/context/rtk/raw-output/[id]` | GET | राखून ठेवलेले संपादित रॉ आउटपुट वाचा |
| `/api/compression/preview` | POST | कोणत्याही संक्षेपण मोडचे पूर्वावलोकन करा |
RTK चाचणी पेलोड:
```json
{
"command": "npm test",
"text": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed",
"config": {
"intensity": "standard"
}
}
```
संक्षेपण पूर्वावलोकन पेलोड:
```json
{
"mode": "stacked",
"messages": [
{
"role": "tool",
"content": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed"
}
],
"config": {
"rtkConfig": {
"rawOutputRetention": "failures"
}
}
}
```
व्यवस्थापन मार्गांसाठी डॅशबोर्ड व्यवस्थापन प्रमाणीकरण किंवा जुळणारे API-की धोरण आवश्यक आहे.
RTK TOML सत्यापन पेलोड:
```json
{
"action": "validate",
"content": "schema_version = 1\n\n[filters.my-tool]\nmatch_command = \"^my-tool\\\\b\"\nmax_lines = 20\n"
}
```
सत्यापित फाइल जागतिक स्तरावर स्थापित करण्यासाठी `"action": "install"` वापरा. अस्तित्वात असलेली जागतिक फाइल बदलण्याचे पुनरावलोकन आणि पुष्टी केल्यानंतरच `"overwrite": true` जोडा.
## कच्चे आउटपुट पुनर्प्राप्त करणे
RTK सामान्यतः फक्त संकुचित मजकूर परत करते. डीबगिंगसाठी, `rawOutputRetention` संपादित केलेले
कच्चे आउटपुट राखून ठेवू शकते:
| मूल्य | वर्तन |
| ---------- | -------------------------------------------------------- |
| `never` | कच्चे आउटपुट राखून ठेवू नका |
| `failures` | फक्त संभाव्य अपयशाचे आउटपुट राखून ठेवा |
| `always` | संपादनानंतर प्रत्येक संकुचित RTK कच्चे आउटपुट राखून ठेवा |
राखून ठेवलेल्या फाइल्स येथे लिहिल्या जातात:
```txt
DATA_DIR/rtk/raw-output/
```
संचयित करण्यापूर्वी गुपिते संपादित केली जातात, ज्यामध्ये सामान्य bearer tokens, API keys, Slack tokens,
AWS access keys आणि assignment-style `token=...`, `secret=...`, `password=...` मूल्यांचा समावेश होतो. विश्लेषणामध्ये
फक्त pointer id, आकार आणि hash metadata साठवले जाते.
## पडताळणी गेट
लक्ष्यित पडताळणी गेट बाह्य कमांड्ससाठी shell वापरल्याशिवाय अंगभूत inline 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
```
रिलीजपूर्वी व्यापक compression गेट चालवा:
```bash
node --import tsx/esm --test \
tests/unit/compression/*.test.ts \
tests/golden-set/*.test.ts \
tests/integration/compression-pipeline.test.ts \
tests/unit/api/compression/compression-api.test.ts
```
## RTK चा विस्तार करणे
1. filter JSON फाइल जोडा किंवा अद्ययावत करा.
2. महत्त्वाचे वर्तन सिद्ध करणारा किमान एक `tests[]` नमुना समाविष्ट करा.
3. नवीन command families साठी `tests/unit/compression/fixtures/rtk/` अंतर्गत fixture जोडा.
4. नवीन output class सादर करताना command detection coverage जोडा.
5. पडताळणी आणि व्यापक RTK गेट्स चालवा.
6. filter प्रकल्प-स्थानिक असल्यास, `.rtk/filters.json` commit करा आणि केवळ पुनरावलोकनानंतर `.rtk/trust.json` रीफ्रेश करा.
---
## तीव्रता पातळ्या (v3.8.16+)
RTK **3 तीव्रता पातळ्यांना** समर्थन देते, ज्या **compression aggressiveness** आणि **safety** यांच्यात संतुलन साधतात. ही पातळी engine config मधील `config.intensity` द्वारे सेट केली जाते.
### 3 पातळ्या
| पातळी | छाटणी मर्यादा | टोकन बचत | जोखीम | यासाठी सर्वोत्तम |
| -------------------- | ----------------------- | -------- | ---------- | ------------------------------------- |
| `minimal` | प्रत्येक विभागात 24 ओळी | ~20-40% | अत्यंत कमी | महत्त्वपूर्ण संदर्भ असलेले production |
| `standard` (डीफॉल्ट) | प्रत्येक विभागात 24 ओळी | ~50-70% | कमी | दैनंदिन coding sessions |
| `aggressive` | प्रत्येक विभागात 16 ओळी | ~70-90% | मध्यम | दीर्घ sessions, कमाल बचत |
### छाटणी कुठे होते
छाटणी मर्यादा `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 त्रुटी | ✅ जतन केलेले | ✅ जतन केलेले | ✅ जतन केलेले |
| चाचणी यश (verbose) | ✅ जतन केलेले | 🟡 संक्षिप्त केलेले | 🟡 संक्षिप्त केलेले |
| नियमित आउटपुट (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/` निर्देशिकेमध्ये **49+ अंगभूत फिल्टर JSON फाइल्स** आहेत. डीफॉल्टमध्ये समाविष्ट नसलेल्या सानुकूल साधनांमधील आउटपुट संक्षिप्त करण्यासाठी तुम्ही स्वतःचे फिल्टर्स जोडू शकता.
### फिल्टर स्कीमा (Zod)
```ts
{
"id": "string", // आवश्यक. फिल्टर ओळखकर्ता (kebab-case, उदा., "python-traceback")
"label": "string", // आवश्यक. मानवाला वाचता येण्याजोगे फिल्टरचे नाव
"description": "string", // पर्यायी (डीफॉल्ट: ""). फिल्टर काय करतो याचे संक्षिप्त वर्णन
"category": "git|test|build|shell|docker|package|infra|cloud|generic",
"priority": number, // पर्यायी (0-100, डीफॉल्ट: 50). अंमलबजावणीचा क्रम (जास्त = प्रथम)
"match": {
"commands": ["string"], // जुळवण्यासाठी कमांडची नावे (उदा., "python", "pytest")
"patterns": ["string"], // आउटपुटशी जुळवण्यासाठी Regex पॅटर्न
"outputTypes": ["string"] // शोधलेले आउटपुट वर्ग (उदा., "test-failure")
},
"rules": {
"stripAnsi": boolean, // पर्यायी (डीफॉल्ट: false). ANSI रंग कोड काढून टाका
"replace": [ // शोधा-आणि-बदला नियम (डीफॉल्ट: [])
{ "pattern": "regex", "replacement": "..." }
],
"matchOutput": [ // पॅटर्न जुळल्यावर शॉर्ट-सर्किट करा (डीफॉल्ट: [])
{
"pattern": "regex",
"message": "short summary",
"unless": "regex" // हा पॅटर्न जुळल्यास वगळा
}
],
"includePatterns": ["string"], // ठेवायच्या ओळी (Regex पॅटर्न, डीफॉल्ट: [])
"dropPatterns": ["string"], // वगळायच्या ओळी (Regex पॅटर्न, डीफॉल्ट: [])
"collapsePatterns": ["string"], // एकाच आवृत्तीमध्ये संकुचित करायच्या ओळी (डीफॉल्ट: [])
"deduplicate": boolean, // पर्यायी (डीफॉल्ट: false). डुप्लिकेट ओळी काढून टाका
"truncateLineAt": number, // पर्यायी (डीफॉल्ट: 0). ओळी कमाल वर्णसंख्येपर्यंत कापा
"maxLines": number, // पर्यायी (डीफॉल्ट: 0). एकूण ओळींवर कठोर मर्यादा
"headLines": number, // पर्यायी (डीफॉल्ट: 20). जुळलेल्या आउटपुटमधील पहिल्या N ओळी ठेवा
"tailLines": number, // पर्यायी (डीफॉल्ट: 20). जुळलेल्या आउटपुटमधील शेवटच्या N ओळी ठेवा
"onEmpty": "string", // पर्यायी (डीफॉल्ट: ""). सर्व ओळी फिल्टर झाल्यास पर्यायी संदेश
"filterStderr": boolean // पर्यायी (डीफॉल्ट: false). stderr आउटपुटही फिल्टर करा
},
"preserve": {
"errorPatterns": ["string"], // नेहमी जतन करणे आवश्यक असलेले पॅटर्न (डीफॉल्ट: [])
"summaryPatterns": ["string"] // अंतिम सारांश ओळीसाठी पॅटर्न (डीफॉल्ट: [])
},
"tests": [ // पडताळणीसाठी इनलाइन चाचण्या (डीफॉल्ट: [])
{
"name": "string", // आवश्यक. चाचणीचे नाव
"input": "sample output", // आवश्यक. नमुना इनपुट मजकूर
"expected": "expected output", // आवश्यक. अपेक्षित संक्षिप्त आउटपुट
"command": "optional command" // पर्यायी. कमांड संदर्भ
}
]
}
```
### उदाहरण: Python 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 # वापरकर्ता-स्तरीय
<project>/.rtk/filters/my-filter.json # प्रकल्प-स्तरीय
```
सुरू होताना `open-sse/services/compression/engines/rtk/filterLoader.ts` मधील `loadRtkFilters()` द्वारे फिल्टर्स स्वयंचलितपणे लोड केले जातात. लोडर पुढील ठिकाणांवरून फिल्टर्स शोधतो:
- अंगभूत कॅटलॉग: `open-sse/services/compression/engines/rtk/filters/`
- वापरकर्ता निर्देशिका: `~/.omniroute/rtk/filters/`
- प्रकल्प निर्देशिका: `<project>/.rtk/filters/`
प्रोग्रामद्वारे फिल्टर्स लोड करण्यासाठी:
```ts
import { loadRtkFilters } from "@omniroute/open-sse/services/compression/engines/rtk/filterLoader";
// पर्याय: customFiltersEnabled (वापरकर्ता/प्रकल्प फिल्टर्स लोड करा, डीफॉल्टनुसार सुरू),
// trustProjectFilters, refresh.
const filters = loadRtkFilters({ customFiltersEnabled: true });
```
### प्रमाणीकरण
लोड करताना फिल्टर्सचे Zod स्कीमाविरुद्ध प्रमाणीकरण केले जाते. चुकीची संरचना असलेला फिल्टर लोड होण्यात अयशस्वी होईल आणि त्रुटी लॉग करेल:
```
RTK_FILTER_LOADER: filter "my-filter" failed validation:
- rules.replace.0.pattern: Invalid regex
- match.commands: must not be empty
```
स्थापित केलेल्या सर्व फिल्टर्सचे प्रमाणीकरण करण्यासाठी, `open-sse/services/compression/engines/rtk/verify.ts` मधून एक्सपोर्ट केलेले `runRtkFilterTests()` कॉल करा.
### सर्वोत्तम पद्धती
1. **नेहमी `tests[]` समाविष्ट करा** — ते तुमचा फिल्टर कार्यरत असल्याचे सिद्ध करतात आणि रिग्रेशन्स टाळतात
2. **शॉर्ट-सर्किट्ससाठी `matchOutput` वापरा** — जर एकाच ओळीत संपूर्ण आशय स्पष्ट होत असेल, तर पूर्ण ब्लॉक बदला
3. **`strip` ऐवजी `keep` ला प्राधान्य द्या** — स्पष्ट "नेहमी जतन करा" नियम हे "नेहमी काढून टाका" नियमांपेक्षा अधिक सुरक्षित असतात
4. **सर्व 3 तीव्रता पातळ्यांवर चाचणी करा** — `minimal` ने कोणताही बदल करू नये आणि `aggressive` ने तरीही त्रुटी जतन कराव्यात
5. **`unless` फील्ड वापरा** — "X उपस्थित असल्यास ट्रिगर करू नका" या अटीने शॉर्ट-सर्किट्स सुरक्षित करा
---
## रॉ आउटपुट पुनर्प्राप्ती आणि पडताळणी गेट
RTK आउटपुटचे आक्रमकपणे संक्षिप्तीकरण करते तेव्हा, डीबगिंग, ऑडिट किंवा रीप्लेसाठी तुम्ही **मूळ मजकूर पुनर्प्राप्त** करू शकता.
### रॉ आउटपुट पुनर्प्राप्ती कशी कार्य करते
```
मूळ आउटपुट (10K टोकन)
│
▼
RTK संक्षिप्तीकरण (rawOutput.enabled=true सह)
│
├─▶ संक्षिप्त आउटपुट (2K टोकन) ──▶ LLM कडे
│
└─▶ मूळ आउटपुट (10K टोकन) ──▶ DB मध्ये संग्रहित
(request_id द्वारे जोडलेले)
```
### रॉ आउटपुट स्टोरेज सक्षम करणे
**प्रत्येक विनंतीसाठी** (कॉम्बो कॉन्फिगरेशनमध्ये):
```json
{
"compression": {
"engine": "rtk",
"intensity": "aggressive",
"rawOutput": {
"enabled": true,
"maxBytes": 1048576 // 1MB मर्यादा
}
}
}
```
**डीफॉल्ट**: `rawOutput.enabled: false` (स्टोरेज वाचवते).
### स्टोरेज खर्च
| प्रत्येक विनंतीसाठी | 1MB मर्यादा | 10MB मर्यादा |
| ----------------------- | ------------- | -------------- |
| सरासरी संक्षिप्त आउटपुट | ~5KB | ~5KB |
| संग्रहित रॉ आउटपुट | ~50-500KB | ~500KB-5MB |
| दररोज 1000 विनंत्यांसह | 50-500MB/दिवस | 500MB-5GB/दिवस |
> **शिफारस**: रॉ आउटपुट नेहमी सुरू ठेवण्याऐवजी केवळ **डीबगिंग सत्रांसाठी** किंवा **नमुना-आधारित ऑडिटिंगसाठी** सक्षम करा.
### मूळ आउटपुट पुनर्प्राप्त करणे
```ts
import { readRtkRawOutput } from "omniroute/compression/engines/rtk/rawOutput";
const raw = readRtkRawOutput(pointerId); // कॉम्प्रेशन आकडेवारीतील 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()` कॉल करा**:
```ts
import { runRtkFilterTests } from "open-sse/services/compression/engines/rtk/verify";
const result = runRtkFilterTests();
console.log(`Passed: ${result.outcomes.filter((o) => o.passed).length}`);
console.log(`Failed: ${result.outcomes.filter((o) => !o.passed).length}`);
if (!result.passed) {
console.error("Filters failed verification");
result.outcomes
.filter((o) => !o.passed)
.forEach((o) => {
console.error(
` - ${o.filterId} / ${o.testName}: expected "${o.expected}", got "${o.actual}"`
);
});
}
```
**ते कशाची पडताळणी करते**:
1. प्रत्येक फिल्टर लोड होतो आणि स्कीमा पडताळणी उत्तीर्ण करतो
2. प्रत्येक `tests[]` नोंद अपेक्षित आउटपुट निर्माण करते
3. `minimal` तीव्रता कोणतीही क्रिया करत नाही (मूळ जतन करते, केवळ संरचनात्मक फिल्टर्स लागू करते)
4. `aggressive` तीव्रता त्रुटी, चाचणी अपयश आणि स्टॅक ट्रेसेस जतन करते
5. संक्षिप्त आउटपुट कधीही मूळ इनपुटपेक्षा मोठे नसते
- स्रोत: `open-sse/services/compression/engines/rtk/` (63 फाइल्स, ~70KB)
- **फिल्टरमधील बदल मर्ज करण्यापूर्वी** — चाचण्या नेहमी उत्तीर्ण होत असल्याची खात्री करा
- **RTK इंजिन अपग्रेड केल्यानंतर** — स्कीमा बदललेली असू शकते
- **नियमित निरीक्षणादरम्यान** — चाचणी फिक्स्चर्समधील विचलनापासून संरक्षण करते
- **नवीन टूल/कमांड फॅमिली जोडताना** — नवीन फिल्टर कार्य करत असल्याचे सिद्ध करते
---
## हे देखील पहा
- [COMPRESSION_GUIDE.md](./COMPRESSION_GUIDE.md) — संपूर्ण कॉम्प्रेशन पाइपलाइनचा आढावा
- [COMPRESSION_ENGINES.md](./COMPRESSION_ENGINES.md) — इंजिन रजिस्ट्री आणि अंगभूत इंजिन्स
- [EXTENDING_COMPRESSION.md](./EXTENDING_COMPRESSION.md) — सानुकूल इंजिन्स, भाषा पॅक्स, स्टॅक्ड पाइपलाइन्स
- स्रोत: `open-sse/services/compression/engines/rtk/` (63 फाइल्स, ~70KB)
Reference in New Issue View Git Blame Copy Permalink