Escaping the History Trap: Building a Data-Driven Autocomplete Engine for PowerShell

 As developers and creators, the terminal is our second home. Whether we are pushing code with Git, debugging Android applications via ADB, or batch-processing hundreds of images with ImageMagick, the command line interface is where the real work happens. But working with CLI-heavy tools in PowerShell has always had a frustrating bottleneck: discovering and remembering commands.

The Illusion of History-Based Autocomplete For a long time, the standard solution has been history-based autocomplete, powered by fantastic tools like PSReadLine. Don't get me wrong, predicting what I'm going to type based on what I typed yesterday is incredibly useful. But history-based systems are, by definition, backward-looking.

What happens when you need to use a flag you've never used before? What if you can't remember if the fastboot partition flag requires a dash? History can't help you there. Your workflow breaks. You switch to a browser, dig through documentation or man pages, and manually type it out. I realized that relying solely on my own terminal history wasn't enough; I needed a forward-looking solution that actually understood the tools I was using.

The Vision: A Data-Driven Engine The traditional way to solve this in PowerShell is by writing custom argument completer scripts for every single tool. This is a tedious approach that is difficult to maintain and creates massive, bloated script files.

I wanted to decouple the logic from the data. The idea for the "Ultimate Completer" was born: a single, lightweight PowerShell engine that builds its autocomplete menus dynamically by reading a structured JSON dictionary. If a tool updates or you want to add a brand-new one to your workflow, you don't touch the PowerShell logic at all—you just update the JSON file.

The Case-Sensitivity Trap and the HashTable Pivot Building the engine wasn't without its technical hurdles. During development, I hit a fascinating roadblock regarding case sensitivity.

Many CLI tools use case-sensitive flags. For example, Git uses -d to delete a merged branch and -D to force-delete an unmerged one. Or take Inkscape, which expects -w to set the export width and -W to query it. JSON handles this perfectly because it is inherently case-sensitive. However, PowerShell's default object parsing (PSCustomObject) is strictly case-insensitive.

When my engine initially tried to convert the JSON dictionary into a PowerShell object, it saw -d and -D as the exact same property, resulting in immediate key collision crashes. The breakthrough came when I rewrote the engine's core to parse the JSON data as a native HashTable. HashTables in PowerShell fully respect case sensitivity. This architectural pivot not only completely resolved the key collisions but also made traversing the deeply nested JSON subcommands significantly faster and more reliable.

Context-Awareness and Stacking The resulting engine turned out to be surprisingly smart. It doesn’t just look at the first word you type; it scans your entire command line context. If you type git commit -, the engine knows you are in the "commit" subcommand context and strictly serves you commit-related flags, complete with helpful tooltips explaining what they do.

Furthermore, I specifically designed it to support flag stacking. For example, when processing images with ImageMagick (magick) and stringing together unique flags like -resize, -quality, and -format, the engine continuously recognizes your root context and keeps serving the remaining available options without breaking a sweat.

Try It Out and Contribute! By shifting the burden of autocomplete from static history to a dynamic, JSON-driven dictionary, the terminal experience feels entirely different. It acts less like a simple memory bank and more like an interactive manual that guides you as you type.

The Ultimate Completer is fully open-source. If you want to see how the code works under the hood or contribute by adding your favorite CLI tools to the JSON library, you can check out the GitHub repository. If you just want to install the module and level up your terminal immediately, you can download it directly from the PowerShell Gallery. All the necessary instructions for installation, profile integration, and expanding the dictionary are available in the repository's README. Let's build the ultimate library together!

[link]

Check out the GitHub Repository!

[/link]