sasqwatch; sizeof; srgn

Just because I’ve focused a bit on MCP servers and other bits in the LLM/GPT universe does not mean I have forgotten the CLI roots of the Drop. Today we have three distinct utilities that provide their own unique value to what are likely everyday tasks for most of the Drop fam.

TL;DR

(This is an LLM/GPT-generated summary of today’s Drop using Ollama + Qwen 3 and a custom prompt.)

• sasqwatch reimagines the Unix watch command with advanced features like output history navigation and diff highlighting, enhancing command monitoring experience (https://github.com/fabio42/sasqwatch)
• sizeof is a simple Go tool that measures the size of strings, URLs, or files in bytes, and serves as an experiment in LLM-assisted development (https://github.com/zackproser/sizeof)
• srgn uses tree-sitter grammars and regex to enable precise, language-aware code manipulation, making it ideal for large-scale refactoring and code analysis (https://github.com/alexpovel/srgn)

sasqwatch: Who Sqwatches The Sqwatchers?

Sometimes the best innovations come from taking something familiar and asking, “What if we could do this better?” That’s precisely what happened with sasqwatch, a Go-based reimagining of the venerable Unix watch command that transforms a simple utility into something pretty spiffy!

While the original watch command dutifully executes your specified command every few seconds and displays the output, sasqwatch treats this as just the starting point. Built on the epic Go Charm Bracelet CLI tooling ecosystem using Bubble Tea, it introduces a suite of features that address the real-world frustrations we’ve all encountered with traditional command monitoring.

Perhaps the coolest feature of this utility is the ability to navigate output history. How many times have you been watching a command’s output, noticed something interesting flash by, and wished you could scroll back to see what changed? sasqwatch records each unique output and lets us navigate through this history with simple [ and ] keystrokes. Simple, yet brilliant!

What impressed me most about sasqwatch is the attention to user experience details. Manual triggering between intervals, diff highlighting to spot changes, configurable memory limits, and proper scrolling support may not garner headlines, but they are super nice quality-of-life extras that show that the authors and contributors are not just tool builders but tool users as well.

Said diff highlighting deserves special mention. You can compare successive outputs or diff against the very first iteration, making it trivial to spot what’s actually changing in your monitored command. For anyone who’s ever stared at streaming logs trying to catch subtle differences, this feels like a genuine superpower.

Getting started is straightforward:

go install github.com/fabio42/sasqwatch@latest

The command-line interface maintains familiar watch semantics while adding flags for the new capabilities:

sasqwatch -d -n 1 "ps aux | grep myprocess"

That -d flag enables diff highlighting, and you’re immediately operating in a more powerful monitoring environment.

If you find yourself using watch regularly, sasqwatch is worth the upgrade. It’s not going to revolutionize your CLI workflows, but it might just eliminate a few daily friction points.

sizeof: ‘Go’ Measure Stuff!

sizeof’s premise is refreshingly straightforward. Pass it a string, URL, or file path, and it spits back the size in bytes along with some helpful context. Need to know how much data you’re working with? Just ask:

sizeof "hello world"
sizeof "https://example.com" 
sizeof "/path/to/your/massive-dataset.json"

Sure, you could use wc, du, stat, file, curl, and grep to get similar information, but sizeof eliminates the cognitive overhead of remembering which CLI command, format strings, and flags to use.

You’ll need to install it via:

% go install github.com/zackproser/sizeof@latest

as there aren’t formal releases (more on that in a moment), so you’re pulling from the main branch. For a tool this focused, I think that’s generally perfectly reasonable.

What makes sizeof particularly interesting is its positioning as both a practical utility and an experiment in LLM/TPT-assisted development. Zachary (the author) explicitly frames this as a testbed for integrating LLMs like ChatGPT-4 and GitHub Copilot into real development workflows.

This is one of the earlier snapshots of “vibe-esque” coding — the kind of rapid prototyping and exploration that’s become possible when developers can bounce ideas off coding assistants and iterate quickly on small, focused tools.

Development appears to have quieted down around two years ago, which presents an interesting opportunity. The core concept is solid, the implementation is clean, and the scope is manageable. These are perfect conditions for community contribution and experimentation.

Whether you’re looking to:

• Add new input formats or measurement types
• Improve the human-readable comparisons
• Experiment with the assisted development approach Proser pioneered here

this is exactly the kind of project where meaningful contributions can have immediate impact. Sometimes the best way to understand a tool is to extend it yourself.

I also like this tool as it is a reminder that innovation often happens in these smaller spaces, where developers can experiment with new approaches (like assisted coding) without the weight of enterprise requirements or massive user bases.

It’s definitely worth checking out, worth hacking on, and definitely worth having in your toolkit for those moments when you just need to know: “How big is that thing, anyway?”

srgn: A Tree-mendous New Way To Slice & Dice Source Code

NOTE: I’ve just started checking this tool out (hence no code examples), but even some quick experiments showed it was worth including in today’s Drop.

sgrn’s has a mission to make searching and manipulating source code with both regex power and genuine language awareness. Traditional text processing tools treat our carefully structured Rust or Go code like any other text file. Many refactoring features in various IDEs are powerful but limited to specific operations. srgn splits the difference beautifully.

A super neat feature is that you can scope operations to syntactic elements using tree-sitter grammars. Want to find all instances of ‘age’ but only within TypeScript class definitions? Done. Need to replace print statements with logging calls but avoid touching the ones in comments or strings? No problem. This is a full evolution from pattern matching anymore to context-aware (literal) code surgery.

Regex patterns handle the familiar cases, while language-aware scopes tackle the scenarios that used to require manual inspection or brittle multi-step workflows. The tool supports C, C#, Go, HCL, Python, Rust, and TypeScript with prepared queries for common constructs like comments, function definitions, and imports.

Performance was paramount for the tool, and it can process hundreds of thousands of lines in seconds through parallelism, so you can use it on “real” codebases, or your hobby projects. The safety features show thoughtful design: search mode won’t overwrite files by default, dry-run previews changes as diffs, and explicit failure modes make it friendly in CI/CD environments.

Sure, tree-sitter has been around for a bit, regex is ancient history, but their combined powers in this context creates something super useful.

The installation options are comprehensive, the documentation is solid, and the command-line interface follows familiar patterns. For large-scale refactoring, enforcing code standards, or any scenario where context matters more than simple text matching, srgn represents a major step forward.

FIN

Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:

• 🐘 Mastodon via @dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev
• 🦋 Bluesky via https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy

☮️