Stop Wasting LLM Tokens! I Built a Rust CLI to Prune JS/TS Codebases by 80% 🦀🚀

┌─────────────────────────────────────────────────────────────────────────────┐ │ THE “INFINITE CONTEXT” TRAP │ ├──────────────────────────────┬──────────────────────────────────────────────┤ │ 1. Attention Degradation │ Lost-in-the-Middle: critical interfaces get │ │ │ buried under repetitive DOM noise and loops. │ ├──────────────────────────────┼──────────────────────────────────────────────┤ │ 2. KV-Cache Prefill Lag │ Time-to-First-Token (TTFT) scales with prompt│ │ │ size; 150k+ raw tokens stall your agent. │ ├──────────────────────────────┼──────────────────────────────────────────────┤ │ 3. The “Tailwind Tax” │ Paying frontier API rates to ingest 80-char │ │ │ strings like “flex items-center justify-…” │ ├──────────────────────────────┼──────────────────────────────────────────────┤ │ 4. Rate-Limit Throttling │ Bloated prompts quickly exhaust TPM (Tokens │ │ │ Per Minute) quotas in CI/CD pipelines. │ └──────────────────────────────┴──────────────────────────────────────────────┘ Have you ever dumped an entire React or Next.js repository into Claude 3.5 Sonnet, GPT-4o, or a local Ollama model to ask: “How does authentication state flow through my UI, and what endpoints handle it?” If you inspect the prompt you sent, over 70% of the tokens are dead weight: Hundreds of lines of static Tailwind CSS utility classes (className=“flex flex-col items-center justify-between p-8 bg-white dark:bg-zinc-950 rounded-2xl shadow-xl…”). Imperative loops, array mappers, and string formatting logic that have nothing to do with application architecture. Missing bird’s-eye views: no clear backend API route table, no dependency graph, and no clean component hierarchy. While 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. I built 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. Here is how it works, how it is architected under the hood, real benchmarks, and the engineering trade-offs you should know before using it. 🏛️ The Philosophy: What is “Urai”? In 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). Master commentators (Uraiyāsiriyars) like Parimelazhagar and Ilampuranar did not just copy or mechanically summarize texts. They performed structural distillation: Isolating the core semantic axioms of each stanza. Stripping linguistic ornamentation that obscured meaning. Exposing grammar, intent, and relationships for reasoned debate. Modern 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. urai-ecma acts as a modern Uraiyāsiriyar for your codebase. ⚡ Synthesis vs. Blind Concatenation Tools 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. 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: ┌─────────────────────────────────────────────────────────────────────────┐ │ URAI COMPILER PIPELINE │ └─────────────────────────────────────────────────────────────────────────┘ Enterprise Monorepo (.ts, .tsx, .js, .mjs, .json) │ ▼ [ignore::WalkBuilder (Rust)] Honor .gitignore, prune node_modules & dist │ ▼ [Rayon Parallel Work-Stealing] Multi-threaded AST parsing across all CPU cores │ ┌───────────────┴───────────────┐ ▼ ▼ [swc_ecma_parser] [swc_ecma_parser] Worker Thread A Worker Thread B │ │ ├─► [RouteVisitor] ├─► [RouteVisitor] │ Next.js/Express/NestJS │ Next.js/Express/NestJS │ │ ├─► [ReactComponentAnalyzer] ├─► [ReactComponentAnalyzer] │ Props, State, Hooks, JSX │ Props, State, Hooks, JSX │ │ ├─► [ReactJsxPruner] ├─► [ReactJsxPruner] │ Tailwind static class strip │ Tailwind static class strip │ │ └─► [FunctionSummarizerVisitor] └─► [FunctionSummarizerVisitor] Preserve structural stubs Preserve structural stubs │ ▼ [Foyer Hybrid Cache (Disk + RAM)] Sha512_256 + Zstd compression │ ▼ [swc_ecma_codegen + Tiktoken Engine] Emits high-density Markdown prompt + BPE o200k report 🎯 The Three Pillars of AST Token Optimization 1. AST Structural Stubbing (is_structural_stub_stmt) Traditional 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). urai-ecma solves this through Structural Stubbing. It inspects AST statements and retains only nodes critical to architectural comprehension: // Only statements defining component anatomy are preserved: fn is_structural_stub_stmt(stmt: &Stmt) -> bool { match stmt { Stmt::Decl(Decl::Fn()) => true, // Nested helper declarations Stmt::Decl(Decl::Var(var_decl)) => var_decl.decls.iter().any(|decl| { if let Some(init) = &decl.init { matches!(**init, Expr::Arrow() | Expr::Fn()) } else { false } }), Stmt::Expr(expr_stmt) => { if let Expr::Call(call_expr) = &*expr_stmt.expr && let Callee::Expr(callee_expr) = &call_expr.callee && let Expr::Ident(ident) = &**callee_expr { let name = ident.sym.as_ref(); // Preserves React Hooks, lifecycle timers, and global listeners: return name.starts_with(“use”) || name == “setTimeout” || name == “setInterval” || name.contains(“addEventListener”) || name.contains(“requestIdleCallback”); } false } Stmt::Return(ret_stmt) => { // Preserves JSX layout hierarchies: if let Some(arg) = &ret_stmt.arg { matches!( &**arg, Expr::JSXElement() | Expr::JSXFragment() | Expr::Paren() ) } else { false } } _ => false, // Computational loops, arithmetic, & validations are pruned } } Hooks stay visible: useEffect(() => { … }, [dep]) remains intact, signaling side-effects to the LLM. JSX hierarchies stay visible: The complete return layout tree remains legible. Imperative logic is replaced: Loops, arithmetic, and validation are replaced with a single synthetic docstring comment. 2. Dynamic-Aware Tailwind Pruning Modern utility CSS accounts for massive token bloat. urai-ecma provides 4 modes (remove, remove_aggr, summarize, preserve): Preserves Dynamic Expressions: If you use dynamic styling like className={clsx(“btn”, isActive && “btn-active”)} or ternary conditions, they are kept 100% intact. Strips or Summarizes Static Strings: Long static class lists exceeding the threshold (default: 96 chars) are either cleanly stripped or sent to a local Ollama model to produce natural-language style summaries (e.g., /* UI: Frosted glass card with dark mode /). 3. JSDoc-First Resolution with Local Ollama Fallback Summarizing every single function with an LLM is slow. urai-ecma uses a two-tier resolution strategy: JSDoc First: It checks whether human-written JSDoc annotations (@description, @param, @return) already exist. It even includes a proximity-scan fallback (within a 300-byte span) to associate detached comments. This takes 0 milliseconds of LLM compute! Local Ollama Fallback: If a function exceeds your line threshold (default: 5 lines) and has no JSDoc, it queries a local Ollama model (gemma4, llama3.2). No code ever leaves your machine. Foyer Hybrid Caching: Results are stored in a dual-tier cache powered by Rust’s foyer crate (64MB direct RAM buffer + 128MB Zstd-compressed disk storage with Sha512_256 keys). 🔍 Real-World Before & After Look at what happens to a bloated React component when passed through urai-ecma: ❌ The Bloated Source Code (Before) const ErrorUI = ({ headerDescTxt = “The real-time telemetry pipeline requires runtime binding. Ensure this window resides in a Chrome extension popup configured with permission parameters.”, copyTextCommand = ‘OLLAMA_ORIGINS="" ollama serve’, copyTagTxt = “MV3”, copyHeaderTxt = “Manifest Interface Schema”, copiedButtonTxt = “Copied Configuration”, copyButtonTxt = “Copy Permission Manifest”, }) => { const [copyState, setCopyState] = useState(false); const handleCopyManifest = () => { navigator.clipboard.writeText(copyTextCommand); setCopyState(true); setTimeout(() => setCopyState(false), 2000); }; const copyButtonTxtNode = copyState ? copiedButtonTxt : copyButtonTxt; return (