Agent skill

CLI Creator

by Arindam200 in Arindam200/termui

Build a complete, working CLI tool using TermUI components. An agent skill from Arindam200/termui.

MITAuto-check passedDevOps & Cloud

Install CLI Creator

skills CLI
$ npx skills add Arindam200/termui --skill cli-creator -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Arindam200/termui cli-creator --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Arindam200/termui.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/cli-creator .claude/skills/cli-creator && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
cli-creator
GitHub stars
141
Token cost
~2.1k tokens
SKILL.md length
632 words
Files
3 (incl. references)
Skills in repo
2
Repo updated
First seen
Licence
MIT

At a glance

Build a complete, working CLI tool using TermUI components. An agent skill from Arindam200/termui.

  • Works in 5 steps: Interview the user → Choose a CLI pattern → Scaffold the project → …
  • Someone describes a CLI
  • SKILL.md covers Step 1 — Interview the user, Step 2 — Choose a CLI pattern, Step 3 — Scaffold the project and Step 4 — Write the code, plus 3 more sections
  • Calls npx and npm

What it does

CLI Creator is an agent skill from Arindam200/termui. Build a complete, working CLI tool using TermUI components. Use this skill whenever someone describes a CLI or TUI app they want to create — a dashboard, a setup wizard, a data browser, a deployment tool, a monitoring app, or any interactive terminal interface. Trigger on phrases like "build me a CLI", "create a terminal app", "make a TUI for", "I want a command-line tool that", "build a CLI that shows", or any request to generate a Node.js CLI from scratch. Even vague requests like "I need a CLI for my project"…

Its SKILL.md is about 2.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/component-picker.md` and `references/patterns.md`).

It sits in DevOps & Cloud. It works with Node.js. The repository describes itself as: TypeScript terminal UI framework. The licence is MIT.

When your agent uses it

  • Someone describes a CLI
  • TUI app they want to create — a dashboard
  • A deployment tool
  • A monitoring app

Example prompts

  • “build me a CLI”
  • “create a terminal app”
  • “make a TUI for”
  • “/cli-creator”

Requirements

  • Node.js
  • Docker

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Interview the user
  2. Choose a CLI pattern
  3. Scaffold the project
  4. Write the code
  5. Component reference quick-pick

What it can do on your machine

Read from SKILL.md and the folder at commit 44de57b. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npx
    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npx and npm, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

CLI Creator loads about 2.1k tokens when it runs, and up to ~9.4k if it reads all its reference files. Until then it costs about 139 tokens; SKILL.md has 632 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~139
When it runs · the whole SKILL.md, loaded when a task matches
~2.1k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~9.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Arindam200/termui at commit 44de57b, republished under its MIT licence (© Arindam200). 632 words, ~2,066 tokens.

Download SKILL.mdSave it as .claude/skills/cli-creator/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
cli-creator
description
Build a complete, working CLI tool using TermUI components. Use this skill whenever someone describes a CLI or TUI app they want to create — a dashboard, a setup wizard, a data browser, a deployment tool, a monitoring app, or any interactive terminal interface. Trigger on phrases like "build me a CLI", "create a terminal app", "make a TUI for", "I want a command-line tool that", "build a CLI that shows", or any request to generate a Node.js CLI from scratch. Even vague requests like "I need a CLI for my project" should trigger this skill.

TermUI CLI Creator

Your job is to build a complete, working CLI project for the user using TermUI. The output is real code — a runnable TypeScript app.

TermUI is a React/Ink-based terminal UI framework. 101 components. Shadcn-style: npx termui add <component> copies source files into the user's project. No runtime registry dependency.


Step 1 — Interview the user

Before writing a single line of code, understand what they're building. Ask these questions (you can batch them):

  1. What does the CLI do? What problem does it solve? (e.g., "manage my deployment configs", "browse GitHub PRs", "monitor server metrics")
  2. What are the main screens or commands? Does it have subcommands (like mytool deploy, mytool logs) or is it one interactive TUI session?
  3. What data does it work with? Lists of things? Forms to fill in? Real-time metrics? File browsing?
  4. Any interactions? Search? Filters? Edit/create/delete? Confirm dialogs?
  5. Visual style? Any theme preference? (Dracula, Nord, Catppuccin, Monokai, Solarized, Tokyo Night, One Dark, or default purple) — default to Dracula if they don't care
  6. Tech context? Do they already have a Node project, or are we starting from zero?

If the request is clear enough (e.g., "build me a Docker container manager with a table view and a detail panel"), skip questions you can infer and just clarify the ones that would change the component selection.


Step 2 — Choose a CLI pattern

Map what they described to one of these patterns. Patterns can be combined.

PatternWhen to useCore components
Data BrowserBrowse/search/filter a list of itemsAppShell + Table or VirtualList + SearchInput
DashboardReal-time metrics, logs, chartsAppShell + Tabs + BarChart/Gauge/Sparkline + useInterval
Setup WizardOnboarding, init, configurationSetupFlow + TextInput/Select/MultiSelect + Spinner
CRUD ManagerCreate / read / update / delete resourcesAppShell + Table + Form/FormField + Modal/Confirm
Auth FlowLogin, token entry, account setupLoginFlow + TextInput/PasswordInput + SetupFlow
Log ViewerStreaming logs, event feedsAppShell + Log + StatusMessage + useAsync
File BrowserNavigate filesystem, pick filesAppShell + DirectoryTree or FilePicker

Full working code for each pattern is in references/patterns.md. Read it before writing code.


Step 3 — Scaffold the project

File structure to generate
<project-name>/
├── package.json
├── tsconfig.json
├── src/
│   ├── index.tsx          ← entry point: render(<App />) wrapped in ThemeProvider
│   ├── app.tsx            ← root App component, handles routing between screens
│   ├── screens/           ← one file per top-level screen/view
│   │   ├── HomeScreen.tsx
│   │   └── DetailScreen.tsx
│   └── components/        ← TermUI components land here after npx termui add
│       └── (added by CLI)
└── termui.config.json     ← created by npx termui init

For single-screen apps (e.g., a simple wizard) you can skip screens/ and put everything in app.tsx.

package.json template
json
{
  "name": "<project-name>",
  "version": "0.1.0",
  "type": "module",
  "bin": { "<project-name>": "./dist/index.js" },
  "scripts": {
    "dev": "tsx src/index.tsx",
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "dependencies": {
    "ink": "^5.0.0",
    "react": "^18.0.0",
    "termui": "latest"
  },
  "devDependencies": {
    "typescript": "^5.4.0",
    "tsx": "^4.7.0",
    "@types/react": "^18.0.0"
  },
  "engines": { "node": ">=18.0.0" }
}
tsconfig.json template
json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "jsx": "react-jsx",
    "jsxImportSource": "react",
    "strict": true,
    "esModuleInterop": true,
    "outDir": "dist"
  },
  "include": ["src"]
}
Show full SKILL.md (269 more words)Show less
Setup commands to give the user
bash
cd <project-name>
npm install
npx termui init                     # sets up termui.config.json
npx termui add <component-list>     # install exactly the components you're using
npm run dev                         # run with tsx (hot-reloading)

Generate the npx termui add command using the kebab-case component names from the registry (e.g., app-shell, table, select, spinner, setup-flow). List only the components the project actually uses.


Step 4 — Write the code

Entry point pattern (src/index.tsx)
tsx
#!/usr/bin/env node
import React from 'react';
import { render } from 'ink';
import { ThemeProvider } from 'termui/core';
import { draculaTheme } from 'termui/core';
import { App } from './app.js';

render(
  <ThemeProvider theme={draculaTheme}>
    <App />
  </ThemeProvider>
);
Root app with screen routing (src/app.tsx)
tsx
import React, { useState } from 'react';

type Screen = 'home' | 'detail' | 'create';

export function App() {
  const [screen, setScreen] = useState<Screen>('home');
  const [selectedId, setSelectedId] = useState<string | null>(null);

  if (screen === 'detail' && selectedId) {
    return <DetailScreen id={selectedId} onBack={() => setScreen('home')} />;
  }
  if (screen === 'create') {
    return <CreateScreen onDone={() => setScreen('home')} />;
  }
  return (
    <HomeScreen
      onSelect={(id) => {
        setSelectedId(id);
        setScreen('detail');
      }}
      onCreate={() => setScreen('create')}
    />
  );
}
Always wrap in ThemeProvider — never render components without it.
Keyboard conventions
  • q / Ctrl+C → quit
  • Escape → go back / cancel
  • ↑↓ → navigate lists
  • Enter → select / confirm
  • Tab / Shift+Tab → switch tabs or focus
  • ? → show help

Implement quit handling in every screen:

tsx
useInput((input, key) => {
  if (input === 'q' || (key.ctrl && input === 'c')) process.exit(0);
  if (key.escape) onBack?.();
});

Step 5 — Component reference quick-pick

Read references/component-picker.md to match user needs to specific components with their exact props.

Read references/patterns.md for complete, copy-paste-ready implementations of each pattern.


Code quality rules

  • Every component that accepts a color prop falls back to useTheme().colors.primary — never hardcode hex
  • Use useState for local UI state, pass callbacks up for cross-screen navigation
  • Keep screens focused — one file per screen, props define the screen's contract
  • For async work (fetching data, running commands), use useAsync from termui/core and show Skeleton or Spinner while loading
  • For data that should persist between sessions, use the conf adapter (termui/conf) which wraps the conf npm package
  • Add ErrorBoundary at the app root so crashes don't leave the terminal in a broken state

Deliver to the user

When done, give them:

  1. Every file with its full content (no placeholders like // TODO)
  2. The exact npx termui add command to run
  3. npm install && npm run dev to try it immediately
  4. A one-line description of the keyboard shortcuts

If the app is complex (3+ screens), walk through what each screen does before showing the code.

© Arindam200, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in skills/cli-creator of Arindam200/termui.

  • SKILL.md
  • references/component-picker.md
  • references/patterns.md

Open the folder on GitHubat commit 44de57b

Compare with similar skills

CLI Creator next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

CLI Creator compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
CLI Creator this skillArindam200/termui141—~2.1kAutomated safety check: PassMIT
Reflexo ReleaseMyriad-Dreamin/typst.ts1.2k—~1.5kAutomated safety check: PassApache-2.0
GitHub Actions CreatorFNOSP/FlyNarwhal4951 repos~2.4kAutomated safety check: PassAGPL-3.0
CI Pipeline Synthesizerkajisho5/ffmpeg-skill1.9k1 repos~1.1kAutomated safety check: PassMIT
GitHub Actions Supply Chain Pinningasyncapi/generator1.1k—~1.9kAutomated safety check: PassApache-2.0
Apm IntegrationsDataDog/dd-trace-js836—~3kAutomated safety check: PassCustom licence

Similar skills

  • Reflexo Release

    Myriad-Dreamin/typst.ts

    Guide Reflexo/typst.ts release preparation and operator handoffs.

    1.2k GitHub stars~1.5k tokensUpdated 13 days ago
    DevOps & CloudAuto-check passed
  • GitHub Actions Creator

    FNOSP/FlyNarwhal

    A skill your agent uses when the user wants to create, generate, or set up a GitHub Actions workflow.

    495 GitHub starsUsed in 1 repo~2.4k tokens
    DevOps & CloudAuto-check passed
  • CI Pipeline Synthesizer

    kajisho5/ffmpeg-skill

    Generate GitHub Actions CI/CD pipeline configurations for automated building and testing of library and package projects.

    1.9k GitHub starsUsed in 1 repo~1.1k tokens
    DevOps & CloudAuto-check passed
  • A skill your agent uses when editing, adding, or reviewing any file under .github/workflows/, or when a CI step installs a CLI tool (npm i -g, npx, pipx, uses: /setup-).

    1.1k GitHub stars~1.9k tokensUpdated 2 days ago
    DevOps & CloudAuto-check passed
  • Apm Integrations

    DataDog/dd-trace-js

    Official

    A skill your agent uses when adding, debugging, fixing, or modifying instrumentation and plugins for third-party libraries in dd-trace-js.

    836 GitHub stars~3k tokensUpdated today
    DevOps & CloudAuto-check passed
  • Close The Loop

    pietheinstrengholt/rssmonster

    A skill your agent uses when a feature has already gone through multiple implementation and review cycles and the work is starting to loop.

    564 GitHub stars~2k tokensUpdated yesterday
    DevOps & CloudAuto-check passed

More from Arindam200/termui

  • Termui

    Arindam200/termui

    Quick reference for TermUI components, hooks, and theming. An agent skill from Arindam200/termui.

    141 GitHub stars~2.8k tokensUpdated 5 mo ago
    Auto-check passed

Works with

Categories

Questions about CLI Creator

What does CLI Creator do?

Build a complete, working CLI tool using TermUI components. An agent skill from Arindam200/termui. CLI Creator is an agent skill from Arindam200/termui. Build a complete, working CLI tool using TermUI components.

When should I use CLI Creator?

CLI Creator fits situations like: someone describes a CLI; TUI app they want to create — a dashboard; A deployment tool; A monitoring app.

How do I install CLI Creator in Claude Code?

Run `npx skills add Arindam200/termui --skill cli-creator -a claude-code`. Or copy the skill folder (skills/cli-creator in Arindam200/termui) into .claude/skills/cli-creator in your project. Claude Code loads it when a task matches its description.

How do I install CLI Creator in Codex?

Run `npx skills add Arindam200/termui --skill cli-creator -a codex`. Or copy the skill folder (skills/cli-creator in Arindam200/termui) into .agents/skills/cli-creator in your project. Codex loads it when a task matches its description.

Can I use CLI Creator in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Arindam200/termui --skill cli-creator -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/cli-creator, .gemini/skills/cli-creator, .github/skills/cli-creator and .opencode/skills/cli-creator in your project.

What does CLI Creator need to run?

Going by SKILL.md and its folder, CLI Creator needs the command-line tools its instructions call (npx and npm). Our summary lists: Node.js; Docker.

Does CLI Creator access the network?

SKILL.md contains no URLs. Its commands use npx and npm, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is CLI Creator safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does CLI Creator use?

CLI Creator is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does CLI Creator use?

About 2.1k tokens (SKILL.md is roughly 8.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 7.3k tokens, read only when the agent opens those files.

What are the alternatives to CLI Creator?

Skills that share tags, products or a category with CLI Creator: Reflexo Release (Myriad-Dreamin/typst.ts, 1.2k stars), GitHub Actions Creator (FNOSP/FlyNarwhal, 495 stars), CI Pipeline Synthesizer (kajisho5/ffmpeg-skill, 1.9k stars) and GitHub Actions Supply Chain Pinning (asyncapi/generator, 1.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains CLI Creator?

Arindam200 (a GitHub user) maintains it in Arindam200/termui, which has 141 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on April 29, 2026.

Source: Arindam200/termui on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.