Cliwright

Skill jjuanrivvera/cliwright/skills/cliwright

Spec-gated CLI factory — generate a complete, agent-ready CLI for any REST API, looped via /goal to a deterministic acceptance gate (make verify).

Install

npx -y skills add jjuanrivvera/cliwright --skill cliwright

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

2 stars2 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Forge a complete, production-grade, agent-ready command-line tool (CLI) for any REST/HTTP API. Use when the user wants to build, scaffold, generate, or create a CLI; wrap an API in a command-line tool; turn an API into a CLI; or make a `gh`-style tool for a service. Produces a Go + Cobra + GoReleaser binary with OS-keyring auth, named profiles, an MCP server, an agent guard, CI/CD, and packaging — and drives the build to completion against a deterministic acceptance gate (`make verify`) so every quality criterion is provably met, not merely asserted. Triggers: "build a CLI for X", "scaffold a CLI", "wrap the X API in a CLI", "make a command-line tool for X", "API to CLI", "create a gh-style CLI".

The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

4.0 KB, as published. Nobody here has run it

cliwright — a wright of CLIs

This skill turns any HTTP API into a polished, distributable CLI built to a single high standard, fully specified in GOAL.md (the canonical playbook). The playbook is self-contained: it does not depend on reading any other repository.

How to run it

Read the playbook. Load GOAL.md (in this skill's directory — it ships next to this SKILL.md, so the same path resolves under both a plugin and a skill-only install). It is the complete brief — architecture, the non-negotiable standard, the meta-command set, the MCP/agent surface, distribution, CI/CD, packaging, reference skeletons, the determinism rules, and the acceptance gate.
Fill the TARGET API block at the top of the playbook. Everything about the API itself (auth, base URL, pagination, rate-limit headers, resources, fields, special ops, JSON quirks) is research, not a question — fetch the docs/OpenAPI and determine it. Only ask the user what the web cannot know (their instance/host, scope preferences, distribution identity), batched into ≤4 questions; skip questions already answered.
Execute the phases in order (Scaffold → Client core → Cross-cutting UX → Meta commands → Resource loop → Agent surface → Beyond-the-API → Tests & gates → Docs → Distribution → Packaging), committing per phase.
Gate on make accept. The build is done only when the acceptance gate passes: make verify (the deterministic gate — make check + coverage + spec-check (CLI surface ⊆ the manifest) + spec-completeness (manifest covers ≥ ~90% of the enumerated API, so a memory-authored manifest can't wrap a fraction of it unnoticed) + the atomic Definition-of-Done checklist) plus the LLM judge rubric for the few subjective items. make accept = verify + judge; the judge spends tokens and needs an agent, so CI and routine runs use the cheaper make verify. See the "Acceptance gate", "Determinism rules", and §0 method-enumeration sections in GOAL.md.

Driving it to completion (the loop)

This skill carries the spec and the gate; it relies on the runtime's native /goal loop as the engine. Run the build under /goal (Claude Code and Codex both ship it), and bind the loop's completion promise to the gate:

The completion promise may be emitted only when make accept exits 0. Never emit a false promise to escape the loop — if the gate fails, keep iterating.

If /goal is unavailable, fall back to the bundled scripts/ralph.sh (a portable while ! make accept; do <agent> continue; done loop).

What it produces

A tagged, installable CLI: Homebrew/Scoop + deb/rpm/apk, signed releases (cosign + SBOM), generated command-reference docs, an mcp server + agent guard, and — if requested — its own Claude Code plugin + cross-tool agent skill.

See references/ for deep dives extracted from the playbook, and templates/ for the copy-in skeletons (generic core, Makefile with the verify target, GoReleaser, CI).