<h1>building my own cli tool</h1>
<p>i've used a lot of developer tools in my time. linters, formatters, analyzers, you name it. they're all useful, but they all share one thing in common: they're too nice. they tell you "this could be improved" when what they really mean is "this code is a disaster and you should feel bad."</p>
<p>i wanted something different. something honest.</p>
<h2>the spark</h2>
<p>it started when i was dealing with a legacy codebase. you know the type, thousands of lines, no comments, variables named <code>data</code>, <code>data2</code>, <code>result</code>, <code>final_final.js</code>. i ran every analyzer we had and they all gave me the same polite suggestions.</p>
<p>i wanted something to look me in the eye and say "this file has strong 'we'll refactor later' energy."</p>
<p>so i built it.</p>
<h2>building wtf-code</h2>
<h3>the stack</h3>
<p>i went with typescript because i wanted type safety. cli tools can get messy fast. for parsing, i used acorn, a javascript ast parser. no ai, no apis, just raw ast analysis.</p>
<p>the core modules:</p>
<ul>
<li><code>analyzer.ts</code> - file and directory analysis</li>
<li><code>metrics.ts</code> - ast-based code metrics</li>
<li><code>complexity.ts</code> - nesting and complexity analysis</li>
<li><code>rating.ts</code> - code scoring from 0 to 10</li>
<li><code>blame.ts</code> - git blame parser</li>
<li><code>diff.ts</code> - git diff reader</li>
<li><code>humor.ts</code> - commentary and phrase pools</li>
<li><code>formatter.ts</code> - chalk-based terminal output</li>
</ul>
<p>each module does one thing and does it well. i tried to keep the architecture clean because i knew if i didn't, the tool would roast its own code, and i couldn't have that.</p>
<h3>the hard parts</h3>
<p><strong>variable name detection</strong> - this was trickier than i expected. extracting variable names from the ast is easy, but determining if they're "vague" required building a whole heuristics system. i ended up creating a list of offender names like <code>data</code>, <code>temp</code>, <code>stuff</code>, <code>thing</code>, <code>result</code>, and variations of <code>final</code>.</p>
<p><strong>the humor</strong> - generating funny commentary without ai was a challenge. i built phrase pools and templates that get selected based on code metrics. if a file has no comments and 400 lines, it gets the "pain" greentext. if it has 5 classes and 2 imports, it gets the "doing too much" joke.</p>
<p><strong>git integration</strong> - parsing git blame and diffs required understanding the output formats. turns out git output is... not great to parse. had to handle a lot of edge cases.</p>
<h3>what i learned</h3>
<p>building a cli tool is different from building web apps. you have to think about:</p>
<ul>
<li>exit codes - what does your tool return when things go wrong?</li>
<li>stdout vs stderr - where does output go?</li>
<li>argument parsing - commander saved me here</li>
<li>cross-platform compatibility - windows paths are fun</li>
</ul>
<h2>the result</h2>
<pre><code>$ wtf project

  Project analysis
──────────────────────────────────────────────────

  Files analyzed: 42

  Largest file:
    server.js (910 lines)

  Code smells detected:
    • large files
    • vague variable names

  Developer commentary:

    this project has strong "we'll refactor later" energy.

──────────────────────────────────────────────────
</code></pre>
<p>exactly what i wanted.</p>
<h2>it's a meme project (but actually useful)</h2>
<p>let's be clear: this started as a joke. i wanted to laugh at bad code instead of cry about it. the greentext format, the roasting, the brutally honest commentary, it's all meant to be funny first.</p>
<p>but here's the thing: behind the memes, it's still a real code analyzer. it counts lines, functions, classes. it detects complexity, nesting depth, code smells. it parses git blame and diffs. the <code>--explain</code> flag gives you a clean technical breakdown without the sarcasm.</p>
<p>so yeah, it's a meme project. but if you strip away the humor, you still get useful metrics. the comedy is just a wrapper around actual analysis.</p>
<p>and honestly? sometimes that's what you need. a tool that makes you laugh while also telling you that your 400-line file has "variable naming confidence level: zero."</p>
<h2>why no ai</h2>
<p>a lot of tools are rushing to add "ai-powered" features. i get it, it's trendy. but i think there's value in deterministic, offline analysis. you don't need an api key. you don't need to send your code to some server. it's just you and the ast.</p>
<p>plus, real developer humor comes from pattern recognition, not language models. the phrase "this function works but nobody knows why" hits different when it's generated from actual code metrics.</p>
<h2>what's next</h2>
<p>typescript better support is planned. right now it only analyzes javascript files, but the ast parsing foundation is there, just need to handle the type annotations.</p>
<p>i also want to add more humor pools. the community has been suggesting phrases and i love it.</p>
<h2>try it out</h2>
<pre><code class="language-bash">npm install -g wtf-code
</code></pre>
<p>then roast your worst file with <code>wtf &#x3C;file> --roast</code>.</p>
<p>sometimes you just need brutal honesty. and that's exactly what this tool delivers.</p>
