{"slug": "stop-wasting-llm-tokens-i-built-a-rust-cli-to-prune-js-ts-codebases-by-80", "title": "Stop Wasting LLM Tokens! I Built a Rust CLI to Prune JS/TS Codebases by 80% ๐ฆ๐", "summary": "A developer built urai-ecma, a multi-threaded Rust CLI that uses SWC to parse JavaScript and TypeScript into ASTs and semantically prune codebases before feeding them to LLMs. The tool reportedly compresses a 209,757-token codebase to roughly 36,000 tokens, an 82.7% reduction, addressing attention degradation, KV-cache prefill lag, and rate-limit throttling in agentic coding workflows.", "body_md": "\n\n```\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\nโ THE \"INFINITE CONTEXT\" TRAP โ\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค\nโ 1. Attention Degradation โ Lost-in-the-Middle: critical interfaces get โ\nโ โ buried under repetitive DOM noise and loops. โ\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค\nโ 2. KV-Cache Prefill Lag โ Time-to-First-Token (TTFT) scales with promptโ\nโ โ size; 150k+ raw tokens stall your agent. โ\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค\nโ 3. The \"Tailwind Tax\" โ Paying frontier API rates to ingest 80-char โ\nโ โ strings like \"flex items-center justify-...\" โ\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโผโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโค\nโ 4. Rate-Limit Throttling โ Bloated prompts quickly exhaust TPM (Tokens โ\nโ โ Per Minute) quotas in CI/CD pipelines. โ\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n```\n\nHave you ever dumped an entire React or Next.js repository into Claude 3.5 Sonnet, GPT-4o, or a local Ollama model to ask:\n\n*\"How does authentication state flow through my UI, and what endpoints handle it?\"*\n\nIf you inspect the prompt you sent, **over 70% of the tokens are dead weight**:\n\n`className=\"flex flex-col items-center justify-between p-8 bg-white dark:bg-zinc-950 rounded-2xl shadow-xl...\"`).\nWhile building an agentic Chrome extension powered by local LLMs, my context window collapsed: **209,757 tokens per scan**. Responses took forever, local inference crawled, and the model routinely hallucinated core functions because key architectural interfaces were buried under syntactic noise.\n\nI built [**`urai-ecma`**](https://sanjaiyan-dev.github.io/urai-ecma): a multi-threaded CLI tool written in **Rust** that uses **SWC (Speedy Web Compiler)** to parse JavaScript and TypeScript into Abstract Syntax Trees (AST). Instead of blindly concatenating files together like a text scraper, it acts as a semantic compiler for prompt engineeringโcompressing that same **209k token codebase down to 36k tokens (an 82.7% reduction) in milliseconds**.\n\nHere is how it works, how it is architected under the hood, real benchmarks, and the engineering trade-offs you should know before using it.\n\nIn classical Tamil literary heritage, monumental masterworks like the *Thirukkuแนaแธท* (เฎคเฎฟเฎฐเฏเฎเฏเฎเฏเฎฑเฎณเฏ) and *Tolkฤppiyam* (เฎคเฏเฎฒเฏเฎเฎพเฎชเฏเฎชเฎฟเฎฏเฎฎเฏ) contained dense, multi-layered philosophical thought. To make these works practical without destroying their architectural depth, classical scholars practiced **เฎเฎฐเฏ เฎเฎดเฏเฎคเฏเฎคเฎฒเฏ (*Urai Ezhuthudhal*)**.\n\nMaster commentators (*Uraiyฤsiriyars*) like **Parimelazhagar** and **Ilampuranar** did not just copy or mechanically summarize texts. They performed **structural distillation**:\n\nModern enterprise JavaScript and TypeScript codebases are the epic literatures of software engineering. When asking an LLM to reason about your code, it doesn't need raw syntactic exhaustionโit needs the structural anatomy, API contracts, state flows, and component signatures.\n\n`urai-ecma` acts as a modern *Uraiyฤsiriyar* for your codebase.\n\nTools like `repomix`, `gitingest`, and `code2prompt` are file dumpers. They walk your directory, wrap raw text in XML/Markdown fences, and pass every single line of styling directly into your model's context.\n\n`urai-ecma` is an **AST-aware compiler engine**. Rather than treating code as raw strings, it parses your source into concrete syntax trees using ByteDance/Vercelโs `swc_ecma` engine and applies deterministic, semantic transformations:\n\n```\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\nโ URAI COMPILER PIPELINE โ\nโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ\n Enterprise Monorepo (.ts, .tsx, .js, .mjs, .json)\n โ\n โผ\n [ignore::WalkBuilder (Rust)]\n Honor .gitignore, prune node_modules & dist\n โ\n โผ\n [Rayon Parallel Work-Stealing]\n Multi-threaded AST parsing across all CPU cores\n โ\n โโโโโโโโโโโโโโโโโดโโโโโโโโโโโโโโโโ\n โผ โผ\n [swc_ecma_parser] [swc_ecma_parser]\n Worker Thread A Worker Thread B\n โ โ\n โโโบ [RouteVisitor] โโโบ [RouteVisitor]\n โ Next.js/Express/NestJS โ Next.js/Express/NestJS\n โ โ\n โโโบ [ReactComponentAnalyzer] โโโบ [ReactComponentAnalyzer]\n โ Props, State, Hooks, JSX โ Props, State, Hooks, JSX\n โ โ\n โโโบ [ReactJsxPruner] โโโบ [ReactJsxPruner]\n โ Tailwind static class strip โ Tailwind static class strip\n โ โ\n โโโบ [FunctionSummarizerVisitor] โโโบ [FunctionSummarizerVisitor]\n Preserve structural stubs Preserve structural stubs\n โ\n โผ\n [Foyer Hybrid Cache (Disk + RAM)]\n Sha512_256 + Zstd compression\n โ\n โผ\n [swc_ecma_codegen + Tiktoken Engine]\n Emits high-density Markdown prompt + BPE o200k report\n```\n\n`is_structural_stub_stmt`)\nTraditional minification forces a bad compromise: either include full function bodies (wasting thousands of tokens on loops and math) or strip functions down to empty signatures (which deletes hooks, event listeners, and JSX layouts).\n\n`urai-ecma` solves this through **Structural Stubbing**. It inspects AST statements and retains only nodes critical to architectural comprehension:\n\n```\n// Only statements defining component anatomy are preserved:\nfn is_structural_stub_stmt(stmt: &Stmt) -> bool {\n match stmt {\n Stmt::Decl(Decl::Fn(_)) => true, // Nested helper declarations\n\n Stmt::Decl(Decl::Var(var_decl)) => var_decl.decls.iter().any(|decl| {\n if let Some(init) = &decl.init {\n matches!(**init, Expr::Arrow(_) | Expr::Fn(_))\n } else {\n false\n }\n }),\n\n Stmt::Expr(expr_stmt) => {\n if let Expr::Call(call_expr) = &*expr_stmt.expr\n && let Callee::Expr(callee_expr) = &call_expr.callee\n && let Expr::Ident(ident) = &**callee_expr\n {\n let name = ident.sym.as_ref();\n // Preserves React Hooks, lifecycle timers, and global listeners:\n return name.starts_with(\"use\")\n || name == \"setTimeout\"\n || name == \"setInterval\"\n || name.contains(\"addEventListener\")\n || name.contains(\"requestIdleCallback\");\n }\n false\n }\n\n Stmt::Return(ret_stmt) => {\n // Preserves JSX layout hierarchies:\n if let Some(arg) = &ret_stmt.arg {\n matches!(\n &**arg,\n Expr::JSXElement(_) | Expr::JSXFragment(_) | Expr::Paren(_)\n )\n } else {\n false\n }\n }\n\n _ => false, // Computational loops, arithmetic, & validations are pruned\n }\n}\n```\n\n`useEffect(() => { ... }, [dep])` remains intact, signaling side-effects to the LLM.\nModern utility CSS accounts for massive token bloat. `urai-ecma` provides 4 modes (`remove`, `remove_aggr`, `summarize`, `preserve`):\n\n`className={clsx(\"btn\", isActive && \"btn-active\")}` or ternary conditions, `/* UI: Frosted glass card with dark mode */`).\nSummarizing every single function with an LLM is slow. `urai-ecma` uses a **two-tier resolution strategy**:\n\n`@description`, `@param`, `@return`) already exist. It even includes a proximity-scan fallback (within a 300-byte span) to associate detached comments. This takes `gemma4`, `llama3.2`). `foyer` crate (64MB direct RAM buffer + 128MB Zstd-compressed disk storage with `Sha512_256` keys).\nLook at what happens to a bloated React component when passed through `urai-ecma`:\n\n``` js\nconst ErrorUI = ({\n headerDescTxt = \"The real-time telemetry pipeline requires runtime binding. Ensure this window resides in a Chrome extension popup configured with permission parameters.\",\n copyTextCommand = 'OLLAMA_ORIGINS=\"*\" ollama serve',\n copyTagTxt = \"MV3\",\n copyHeaderTxt = \"Manifest Interface Schema\",\n copiedButtonTxt = \"Copied Configuration\",\n copyButtonTxt = \"Copy Permission Manifest\",\n}) => {\n const [copyState, setCopyState] = useState(false);\n\n const handleCopyManifest = () => {\n navigator.clipboard.writeText(copyTextCommand);\n setCopyState(true);\n setTimeout(() => setCopyState(false), 2000);\n };\n\n const copyButtonTxtNode = copyState ? copiedButtonTxt : copyButtonTxt;\n return (\n