mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-21 22:32:22 +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

63 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 · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇹🇭 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లోని డిటెక్టర్ ఫిల్టర్ ఎంపికకు ముందు అవుట్పుట్ను వర్గీకరిస్తుంది. కమాండ్ క్లాస్ సరిపోనప్పుడు ఫిల్టర్లు కమాండ్ నమూనా లేదా అవుట్పుట్ రెగ్యులర్ ఎక్స్ప్రెషన్ ఆధారంగా కూడా సరిపోలగలవు.

ఫిల్టర్ రిజల్యూషన్

RTK ఈ క్రమంలో ఫిల్టర్లను లోడ్ చేస్తుంది:

విశ్వసనీయమైనప్పుడు మాత్రమే .rtk/filters.toml మరియు .rtk/filters.json నుండి ప్రాజెక్ట్ ఫిల్టర్లు.
DATA_DIR/rtk/filters.toml మరియు DATA_DIR/rtk/filters.json నుండి గ్లోబల్ ఫిల్టర్లు.
open-sse/services/compression/engines/rtk/filters/ నుండి అంతర్నిర్మిత ఫిల్టర్లు.

ఒకే స్కోప్లో, OmniRoute JSON ఫిల్టర్ల కంటే RTK TOML schema v1 ఫిల్టర్లకు ప్రాధాన్యం ఉంటుంది. దిగుమతి చేసిన కమాండ్-నిర్దిష్ట ఫిల్టర్ ఆ స్కోప్లోని విస్తృత ఫిల్టర్ను ఓవర్రైడ్ చేయగలిగేలా, కమాండ్-టైప్ మ్యాచింగ్కు ముందు TOML match_command ఎక్స్ప్రెషన్లు తనిఖీ చేయబడతాయి. ఫైల్ ఫార్మాట్తో సంబంధం లేకుండా, గ్లోబల్ స్కోప్ కంటే ప్రాజెక్ట్ స్కోప్కే ప్రాధాన్యం ఉంటుంది.

రెగ్యులర్ ఎక్స్ప్రెషన్ ఫిల్టర్లు టూల్ అవుట్పుట్ను ఏజెంట్లకు చూపించే విధానాన్ని మార్చగలవు కాబట్టి, ప్రాజెక్ట్ ఫిల్టర్లు ఉద్దేశపూర్వకంగా ట్రస్ట్-గేట్ చేయబడతాయి. కింది వాటిలో ఒకటి నిజమైనప్పుడు ప్రాజెక్ట్ ఫిల్టర్ ఫైల్ ఆమోదించబడుతుంది:

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 అనుకూలత

RTK TOML స్కీమా v1ను ఉపయోగించే డిక్లరేటివ్ ఫిల్టర్ ఫైల్లను OmniRoute పార్స్ చేయగలదు, ధ్రువీకరించగలదు, పరీక్షించగలదు మరియు ఇన్స్టాల్ చేయగలదు. మద్దతు ఉన్న ఫీల్డ్లు description, match_command, strip_ansi, filter_stderr, strip_lines_matching, keep_lines_matching, replace, match_output, truncate_lines_at, head_lines, tail_lines, max_lines, on_empty మరియు [[tests.<filter>]] ఇన్లైన్ పరీక్షలు. తెలియని ఫీల్డ్లు, చెల్లని లేదా అసురక్షిత రెగ్యులర్ ఎక్స్ప్రెషన్లు, ఏకకాల strip/keep నియమాలు, 1 MiB కంటే పెద్ద ఫైల్లు మరియు తెలియని ఫిల్టర్లకు సంబంధించిన సూచనలు తిరస్కరించబడతాయి. ఇన్లైన్ పరీక్షలు విఫలమైన ఫైల్ను తనిఖీ కోసం ధ్రువీకరించవచ్చు, కానీ దాన్ని ఇన్స్టాల్ చేయడం లేదా లోడ్ చేయడం సాధ్యం కాదు. అనుకూల ఫైల్ లోడ్ వైఫల్యాలు fail-openగానే ఉంటాయి: చెల్లని ఫైల్ దాటవేయబడుతుంది మరియు మిగిలిన ఫిల్టర్లు పని చేస్తూనే ఉంటాయి.

క్లయింట్ ఇప్పటికే టూల్ అవుట్పుట్ను క్యాప్చర్ చేసిన తర్వాత OmniRoute దాన్ని స్వీకరిస్తుంది, కాబట్టి filter_stderr = true ప్రాసెస్ క్యాప్చర్ను మార్చలేదు. ఈ ఫీల్డ్ ఎటువంటి చర్య చేయనిదిగా అంగీకరించబడుతుంది మరియు ధ్రువీకరణ ఒక హెచ్చరికను అందిస్తుంది. దీన్ని ఉద్దేశపూర్వకంగా RTK TOML స్కీమా v1 అనుకూలతగా వర్ణించారు; RTK ఎగ్జిక్యూటబుల్, షెల్ హుక్లు, Rust కమాండ్ అమలులు లేదా దాని ట్రస్ట్-స్టోర్ లేఅవుట్తో పూర్తి అనుకూలతగా కాదు.

డ్యాష్బోర్డ్లోని అధునాతన RTK వ్యూ పేస్ట్ చేసిన లేదా అప్లోడ్ చేసిన TOMLను స్వీకరిస్తుంది. ధ్రువీకరణ రీడ్-ఓన్లీ. ఇన్స్టాలేషన్ పరిమిత అనుమతులతో DATA_DIR/rtk/filters.tomlను అటామిక్గా రాస్తుంది మరియు పునఃప్రారంభం లేకుండానే లైవ్ ఫిల్టర్ కేటలాగ్ను రిఫ్రెష్ చేస్తుంది. ఇప్పటికే ఉన్న ఫైల్ను భర్తీ చేయడానికి స్పష్టమైన overwrite నిర్ధారణ అవసరం మరియు ముందుగా DATA_DIR/rtk/filters.toml.bak సృష్టించబడుతుంది.

ఫిల్టర్ DSL

ఫిల్టర్లు కంప్రెషన్ నియమాల ఫార్మాట్లో వివరించిన JSON స్కీమాను ఉపయోగిస్తాయి. రన్టైమ్ ఈ దశలను క్రమంగా వర్తింపజేస్తుంది:

stripAnsi -> filterStderr -> replace -> matchOutput -> drop/include lines
  -> truncateLineAt -> head/tail/maxLines -> onEmpty

ముఖ్యమైన ఫీల్డ్లు:

ఫీల్డ్	ఉద్దేశ్యం
`rules.stripAnsi`	సరిపోల్చే ముందు టెర్మినల్ రంగు/నియంత్రణ సీక్వెన్స్లను తొలగించడం
`rules.filterStderr`	సరిపోల్చడం/ఫిల్టర్ చేయడం ముందు సాధారణ stderr ప్రిఫిక్స్లను సాధారణీకరించడం
`rules.replace`	క్రమబద్ధమైన రెగ్యులర్ ఎక్స్ప్రెషన్ రీప్లేస్మెంట్లను వర్తింపజేయడం
`rules.matchOutput`	అవుట్పుట్ తెలిసిన స్థితితో సరిపోలినప్పుడు సంక్షిప్త సారాంశాన్ని అందించడం
`rules.matchOutput[].unless`	ఎర్రర్/వైఫల్య నమూనా ఉన్నప్పుడు షార్ట్కట్ను దాటవేయడం
`rules.dropPatterns`	అనవసరమైన శబ్దపూరిత లైన్లను తొలగించడం
`rules.includePatterns`	చర్య తీసుకోదగిన లైన్లకు ప్రాధాన్యమివ్వడం
`rules.collapsePatterns`	పునరావృతమయ్యే సరిపోలే లైన్లను కుదించడం
`rules.deduplicate`	ప్రతి ఫిల్టర్కు ఐచ్ఛిక ఎంపిక: వరుసగా ఉన్న నకిలీ లైన్లను కుదించడం
`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 పార్సర్ను ఉపయోగిస్తుంది (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 ద్వారా అందుబాటులో ఉంటాయి.

{
  "defaultMode": "stacked",
  "autoTriggerMode": "stacked",
  "autoTriggerTokens": 32000,
  "stackedPipeline": [
    { "engine": "rtk", "intensity": "standard" },
    { "engine": "caveman", "intensity": "full" }
  ],
  "rtkConfig": {
    "enabled": true,
    "intensity": "standard",
    "applyToToolResults": true,
    "applyToCodeBlocks": false,
    "applyToAssistantMessages": false,
    "enabledFilters": [],
    "disabledFilters": [],
    "maxLinesPerResult": 120,
    "maxCharsPerResult": 12000,
    "deduplicateThreshold": 3,
    "customFiltersEnabled": true,
    "trustProjectFilters": false,
    "rawOutputRetention": "never",
    "rawOutputMaxBytes": 1048576,
    "enableGrouping": false,
    "groupingThreshold": 3,
    "stripCodeComments": false,
    "preserveDocstrings": true
  }
}

enabledFilters మరియు disabledFilters ఫిల్టర్ ఐడీలను ఉపయోగిస్తాయి, ఉదాహరణకు test-vitest లేదా git-diff.

పూర్తి rtkConfig నిర్మాణం open-sse/services/compression/types.tsలోని RtkConfig / DEFAULT_RTK_CONFIG ద్వారా నిర్వచించబడింది. మొత్తం ఆబ్జెక్ట్ SQLite key_value పట్టికలో namespace = "compression", key = "rtkConfig" కింద ఒకే JSON విలువగా నిల్వ చేయబడుతుంది (src/lib/db/compression.ts), మరియు చదివేటప్పుడు normalizeRtkConfig ద్వారా సాధారణీకరించబడుతుంది. కాబట్టి దిగువన ఉన్న ప్రతి ఫీల్డ్ — enableGrouping, groupingThreshold, stripCodeComments, మరియు preserveDocstringsతో సహా — అదే స్టోర్ ద్వారా రౌండ్-ట్రిప్ అవుతుంది మరియు పునఃప్రారంభం తర్వాత కూడా నిలిచి ఉంటుంది.

కీ	డిఫాల్ట్	ఉద్దేశ్యం
`deduplicateThreshold`	`3`	మొత్తం ఇంజిన్కు: కుదించాల్సిన వరుస సారూప్య పంక్తుల కనిష్ఠ సంఖ్య (2–100కు పరిమితం)
`enableGrouping`	`false`	ఆప్ట్-ఇన్: దాదాపు సమానమైన వరుస పంక్తుల శ్రేణులను కుదించండి
`groupingThreshold`	`3`	గ్రూపింగ్ను ట్రిగ్గర్ చేసే వరుస సారూప్య పంక్తుల శ్రేణి కనిష్ఠ సంఖ్య
`stripCodeComments`	`false`	ఆప్ట్-ఇన్: ఫెన్స్డ్ కోడ్ బ్లాక్ల నుండి వ్యాఖ్యలను తొలగించండి (`applyToCodeBlocks` అవసరం)
`preserveDocstrings`	`true`	వ్యాఖ్యలను తొలగించేటప్పుడు, JSDoc/`/** … */` బ్లాక్లను ఉంచండి

API

రూట్	పద్ధతి	ఉద్దేశ్యం
`/api/context/rtk/config`	GET	RTK కాన్ఫిగ్ను చదవండి
`/api/context/rtk/config`	PUT	RTK కాన్ఫిగ్ను నవీకరించండి
`/api/context/rtk/filters`	GET	ఫిల్టర్ కేటలాగ్ మరియు లోడ్ డయాగ్నస్టిక్స్ జాబితా
`/api/context/rtk/import`	POST	RTK TOML schema v1 ఫైళ్లను ధ్రువీకరించండి లేదా ఇన్స్టాల్ చేయండి
`/api/context/rtk/test`	POST	ఒక టెక్స్ట్ పేలోడ్ కోసం RTK కంప్రెషన్ను ప్రివ్యూ చేయండి
`/api/context/rtk/raw-output/[id]`	GET	నిల్వ ఉంచిన, సున్నిత సమాచారం తొలగించిన ముడి అవుట్పుట్ను చదవండి
`/api/compression/preview`	POST	ఏదైనా కంప్రెషన్ మోడ్ను ప్రివ్యూ చేయండి

RTK పరీక్ష పేలోడ్:

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

కంప్రెషన్ ప్రివ్యూ పేలోడ్:

{
  "mode": "stacked",
  "messages": [
    {
      "role": "tool",
      "content": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed"
    }
  ],
  "config": {
    "rtkConfig": {
      "rawOutputRetention": "failures"
    }
  }
}

నిర్వహణ రూట్లకు డాష్బోర్డ్ నిర్వహణ ప్రమాణీకరణ లేదా సరిపోలే API-కీ విధానం అవసరం.

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/

నిలకడగా భద్రపరచడానికి ముందు రహస్యాలు సవరించబడతాయి, వీటిలో సాధారణ బేరర్ టోకెన్లు, API కీలు, Slack టోకెన్లు, AWS యాక్సెస్ కీలు, అలాగే అసైన్మెంట్-శైలి token=..., secret=..., password=... విలువలు ఉంటాయి. విశ్లేషణలు పాయింటర్ id, పరిమాణం మరియు హాష్ మెటాడేటాను మాత్రమే నిల్వ చేస్తాయి.

ధృవీకరణ గేట్

కేంద్రీకృత ధృవీకరణ గేట్ బాహ్య కమాండ్లను షెల్ ద్వారా అమలు చేయకుండానే అంతర్నిర్మిత ఇన్లైన్ ఫిల్టర్ పరీక్షలను అమలు చేస్తుంది:

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/ కింద ఒక ఫిక్చర్ను జోడించండి.
కొత్త అవుట్పుట్ తరగతిని ప్రవేశపెట్టేటప్పుడు కమాండ్ గుర్తింపు కవరేజ్ను జోడించండి.
ధృవీకరణ మరియు విస్తృత RTK గేట్లను అమలు చేయండి.
ఫిల్టర్ ప్రాజెక్ట్కు స్థానికమైనదైతే, సమీక్ష తర్వాత మాత్రమే .rtk/filters.jsonను కమిట్ చేసి .rtk/trust.jsonను రిఫ్రెష్ చేయండి.

తీవ్రత స్థాయిలు (v3.8.16+)

RTK కంప్రెషన్ దూకుడు మరియు భద్రత మధ్య సమతుల్యతను అందించే 3 తీవ్రత స్థాయిలకు మద్దతు ఇస్తుంది. ఇంజిన్ కాన్ఫిగ్లోని 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
లోపాలు / స్టాక్ ట్రేస్లు	✅ భద్రపరచబడతాయి	✅ భద్రపరచబడతాయి	✅ భద్రపరచబడతాయి
పరీక్ష వైఫల్యాలు	✅ భద్రపరచబడతాయి	✅ భద్రపరచబడతాయి	✅ భద్రపరచబడతాయి
బిల్డ్ లోపాలు	✅ భద్రపరచబడతాయి	✅ భద్రపరచబడతాయి	✅ భద్రపరచబడతాయి
పరీక్ష విజయాలు (వివరణాత్మకం)	✅ భద్రపరచబడతాయి	🟡 కుదించబడతాయి	🟡 కుదించబడతాయి
సాధారణ అవుట్పుట్ (సమాచార లాగ్లు)	🟡 కుదించబడతాయి	🟡 కుదించబడతాయి	❌ తొలగించబడతాయి
పురోగతి పట్టీలు	🟡 కుదించబడతాయి	❌ తొలగించబడతాయి	❌ తొలగించబడతాయి
బ్యానర్ / ASCII కళ	🟡 కుదించబడతాయి	❌ తొలగించబడతాయి	❌ తొలగించబడతాయి

సరైన తీవ్రతను ఎంచుకోవడం

                  సందర్భాన్ని కోల్పోవడం విపత్కరమా?
                  │
      ┌───────────┼───────────┐
      │           │           │
    అవును         కాదు       ఖచ్చితంగా తెలియదు
      │           │           │
      ▼           │           │
   minimal        │           │
      │           │           │
      │           ▼           ▼
      │      నిర్గమ సామర్థ్యం   ముందుగా `standard`ను ప్రయత్నించండి
      │      ఎంత కీలకం?       (80% సందర్భాల్లో
      │           │          పనిచేస్తుంది)
      │      ┌────┴────┐
      │      │         │
      │    తక్కువ      ఎక్కువ
      │      │         │
      │      ▼         ▼
      │   standard   aggressive
      │      │         │
      └──────┴─────────┘

తీవ్రతను కాన్ఫిగర్ చేయడం

ప్రతి కాంబోకు (కాంబో కాన్ఫిగ్లో):

{
  "combo": "my-coding-combo",
  "routing": {/* ... */},
  "compression": {
    "engine": "rtk",
    "intensity": "aggressive"
  }
}

ప్రోగ్రామాటిక్గా:

rtkEngine (@omniroute/open-sse/services/compression/engines/rtk) ఒక CompressionEngine, దీనికి updateConfig మెథడ్ లేదు. దానికి బదులుగా రిజిస్ట్రీ హెల్పర్ ద్వారా ఇంజిన్ కాన్ఫిగ్ను నవీకరించండి:

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: filter "my-filter" failed validation:
  - rules.replace.0.pattern: Invalid regex
  - match.commands: must not be empty

ఇన్స్టాల్ చేసిన అన్ని ఫిల్టర్లను ధృవీకరించడానికి, open-sse/services/compression/engines/rtk/verify.ts నుండి ఎగుమతి చేయబడిన runRtkFilterTests()ను కాల్ చేయండి.

ఉత్తమ పద్ధతులు

ఎల్లప్పుడూ tests[]ను చేర్చండి — అవి మీ ఫిల్టర్ పనిచేస్తుందని నిరూపించి, రిగ్రెషన్లను నివారిస్తాయి
షార్ట్-సర్క్యూట్ల కోసం matchOutputను ఉపయోగించండి — ఒకే లైన్ మొత్తం విషయాన్ని తెలియజేస్తే, మొత్తం బ్లాక్ను దానితో భర్తీ చేయండి
strip కంటే keepకు ప్రాధాన్యం ఇవ్వండి — స్పష్టమైన "ఎల్లప్పుడూ భద్రపరచు" నియమాలు, "ఎల్లప్పుడూ తొలగించు" నియమాల కంటే సురక్షితమైనవి
మూడు తీవ్రత స్థాయిలన్నింటిలో పరీక్షించండి — minimal ఎలాంటి మార్పూ చేయకూడదు, aggressive అయినప్పటికీ లోపాలను భద్రపరచాలి
unless ఫీల్డ్ను ఉపయోగించండి — "X ఉన్నప్పుడు ట్రిగ్గర్ చేయవద్దు" అనే షరతుతో షార్ట్-సర్క్యూట్లను నియంత్రించండి

ముడి అవుట్పుట్ పునరుద్ధరణ & ధృవీకరణ గేట్

RTK అవుట్పుట్ను తీవ్రంగా కుదించినప్పుడు, డీబగ్గింగ్, ఆడిట్ లేదా రీప్లే కోసం మీరు అసలు టెక్స్ట్ను పునరుద్ధరించవచ్చు.

ముడి అవుట్పుట్ పునరుద్ధరణ ఎలా పనిచేస్తుంది

అసలు అవుట్పుట్ (10K టోకెన్లు)
        │
        ▼
RTK కుదింపు (rawOutput.enabled=trueతో)
        │
        ├─▶ కుదించిన అవుట్పుట్ (2K టోకెన్లు)  ──▶ LLMకు
        │
        └─▶ అసలు అవుట్పుట్ (10K టోకెన్లు)   ──▶ DBలో నిల్వ చేయబడుతుంది
                                                  (request_id ద్వారా లింక్ చేయబడింది)

ముడి అవుట్పుట్ నిల్వను ప్రారంభించడం

ప్రతి అభ్యర్థనకు (కాంబో కాన్ఫిగ్లో):

{
  "compression": {
    "engine": "rtk",
    "intensity": "aggressive",
    "rawOutput": {
      "enabled": true,
      "maxBytes": 1048576 // 1MB పరిమితి
    }
  }
}

డిఫాల్ట్: rawOutput.enabled: false (నిల్వను ఆదా చేస్తుంది).

నిల్వ వ్యయం

ప్రతి అభ్యర్థనకు	1MB పరిమితి	10MB పరిమితి
సగటు కుదించిన అవుట్పుట్	~5KB	~5KB
నిల్వ చేసిన ముడి అవుట్పుట్	~50-500KB	~500KB-5MB
రోజుకు 1000 అభ్యర్థనలతో	50-500MB/రోజు	500MB-5GB/రోజు

సిఫార్సు: ముడి అవుట్పుట్ను ఎల్లప్పుడూ ప్రారంభించి ఉంచకుండా, డీబగ్గింగ్ సెషన్లు లేదా నమూనా ఆధారిత ఆడిటింగ్ కోసం మాత్రమే ప్రారంభించండి.

అసలైనదాన్ని పునరుద్ధరించడం

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()ను కాల్ చేయండి:

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)

63 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 ట్రేస్బ్యాక్ ఫిల్టర్

అనుకూల ఫిల్టర్లను లోడ్ చేయడం

ధృవీకరణ

ఉత్తమ పద్ధతులు

ముడి అవుట్పుట్ పునరుద్ధరణ & ధృవీకరణ గేట్

ముడి అవుట్పుట్ పునరుద్ధరణ ఎలా పనిచేస్తుంది

ముడి అవుట్పుట్ నిల్వను ప్రారంభించడం

నిల్వ వ్యయం

అసలైనదాన్ని పునరుద్ధరించడం

ధృవీకరణ గేట్

ఇవి కూడా చూడండి

63 KiB

Raw Blame History

లైన్ గ్రూపింగ్ (`enableGrouping`)

కోడ్ కామెంట్ తొలగింపు (`stripCodeComments` / `preserveDocstrings`)