mvanhorn/cli-printing-press

Worth a look if you spend time hand-writing CLI wrappers so an agent can talk to a service; expect to invest in Go and a tested agent setup first.

The problem

You want an agent to use a third-party API. Today that usually means finding the spec, deciding which endpoints matter, writing argument parsing, fixing auth handling, and then watching the agent guess at flags because the CLI never told it what success looked like. Each new service repeats the same scaffolding. Printing Press aims to shorten that loop: you name the API in an agent session, and it produces a Go CLI and MCP server from a spec, a HAR capture, or just a URL, then runs verification on the result project instructions.

What's different

The generator does more than wrap endpoints. It adds a local data layer: domain-specific SQLite tables for high-volume resources, FTS5 search, incremental sync with cursor tracking, and sql access, so an agent can cache data and query it offline instead of pulling the full API for every question. It also generates compound commands and what the author calls the API's "non-obvious insight," a reframing used to shape those commands. The output targets agent use in detail: typed exit codes, --compact output, and automatic JSON when piped.

The workflow is split into named phases, from spec resolution through ecosystem review, generation, a verification block, and an optional read-only live smoke test. That structure is the main trade-off. The tool wants to be driven through a slash command, and the author's numbers put much of the work in research and design phases of 5–20 minutes rather than a single generation command. The README is direct about what scores mean: a high scorecard reflects structural conformance, not an afternoon of real use. Treat generated code as a draft to review, especially on write paths, since live verification is read-only only limitations.

Who should try it

A good fit is a developer who repeatedly needs agent-callable CLIs for services with messy or missing documentation, and who is comfortable reading the generated Go and refining it. The offline SQLite and search layer matters most for APIs where an agent asks similar questions repeatedly. A poor fit is someone who only occasionally needs a one-off wrapper, or who works outside the tested Claude Code flow: the binary works standalone, and Codex has documented installation, but the author says the curated loop is tested first in Claude Code and Codex behavior may lag install notes. Teams that cannot review generated code or accept using a service in ways its terms forbid should stop at the limitations section.

Requirements and limitations

Installation needs both the Go binary and the skills; neither half is useful alone. That means Go 1.26.10 or newer, Node/npm for npx, and an agent that can load the skills install. The default test path is Claude Code. Setup also involves PATH and auth checks that can fail quietly, and the README includes a troubleshooting section for those cases rather than a single smooth install.

Ongoing care is the bigger constraint. Generated CLIs are described as covering the agent power-user surface, not replacing a vendor's official CLI. Permission to use an API is explicitly separate from the technical ability to generate a client, so you must review the service's terms. Browser capture is manual and can fail on websocket, gRPC, or bot-detected sites; HAR import is the fallback. regen-merge, for regenerating while keeping local changes, is macOS/Linux only. There is no standalone distribution today, and the slash command is the supported entry point.

HotRepo's take

The only dated HotRepo observation is 2026-10-28, when the repository stood at 4,859 stars and had gained 7 that day on the daily board, where it ranked 4th on the new-repository board trending snapshot. With a single recorded board day, persistence cannot be judged; this is a snapshot, not momentum. The useful decision point is not the star count but whether the generated CLI for your specific API passes review on the paths you actually write to. Before committing, generate one and inspect its auth handling, its write commands, and the sync/cache behavior against your use case.