playbooks

home / skills / a5c-ai / babysitter / cli-framework-builder

cli-framework-builder skill

/plugins/babysitter/skills/babysit/process/specializations/sdk-platform-development/skills/cli-framework-builder

This skill helps you design and generate robust CLI frameworks for SDK interaction, including prompts, completions, and configuration across multiple languages.

npx playbooks add skill a5c-ai/babysitter --skill cli-framework-builder

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.0 KB
---
name: cli-framework-builder
description: Build command-line interfaces for SDK interaction
allowed-tools:
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Bash
---

# CLI Framework Builder Skill

## Overview

This skill builds professional command-line interfaces for SDK interaction, including command structure, interactive prompts, shell completions, and configuration management.

## Capabilities

- Design CLI command structure and hierarchy
- Implement interactive prompts and wizards
- Generate shell completions (bash, zsh, fish)
- Support configuration file management
- Implement colored output and progress bars
- Handle authentication flows in CLI
- Support multiple output formats (JSON, table, plain)
- Implement plugin systems for extensibility

## Target Processes

- CLI Tool Development
- Developer Experience Optimization
- SDK Onboarding and Tutorials

## Integration Points

- oclif for Node.js CLIs
- cobra for Go CLIs
- click/typer for Python CLIs
- clap for Rust CLIs
- Configuration managers

## Input Requirements

- Command structure requirements
- Authentication methods
- Output format needs
- Plugin system requirements
- Configuration management needs

## Output Artifacts

- CLI application framework
- Command implementations
- Shell completion scripts
- Configuration management
- Interactive prompt flows
- Plugin system

## Usage Example

```yaml
skill:
  name: cli-framework-builder
  context:
    framework: oclif
    commands:
      - name: auth
        subcommands: [login, logout, status]
      - name: api
        subcommands: [get, post, list]
      - name: config
        subcommands: [set, get, list]
    features:
      shellCompletions: true
      interactiveMode: true
      outputFormats: [json, table, plain]
      configFile: ~/.mysdkrc
    plugins:
      enabled: true
      registry: npm
```

## Best Practices

1. Follow CLI design conventions
2. Provide helpful error messages
3. Support both interactive and scripted use
4. Generate shell completions
5. Implement proper exit codes
6. Support configuration files

Overview

This skill builds professional command-line interfaces for SDK interaction, focusing on structure, usability, and extensibility. It produces a complete CLI framework with commands, interactive flows, shell completions, configuration management, and plugin support. The result is a maintainable, scriptable CLI that accelerates SDK onboarding and developer workflows.

How this skill works

I take your command structure, authentication needs, output format requirements, and plugin expectations and generate a scaffolding and implementation plan for the target language/framework (Node oclif, Go cobra, Python click/typer, Rust clap, etc.). I create interactive prompt flows, completion scripts, configuration file handling, and output formatters so the CLI works both interactively and in CI. I also include best-practice behaviors like clear errors, exit codes, and progress UI.

When to use it

  • You need a robust CLI for an SDK or service that developer teams will use daily.
  • You want both interactive and non-interactive (scriptable) modes supported by one tool.
  • You need cross-shell completions and polished developer onboarding.
  • You plan to support plugins or extendability for third-party integrations.
  • You want standardized config file handling, auth flows, and multiple output formats.

Best practices

  • Design a clear command hierarchy with discoverable subcommands and concise help text.
  • Support both interactive prompts and non-interactive flags for automation.
  • Provide shell completion scripts (bash, zsh, fish) to improve discoverability and speed.
  • Return proper exit codes and actionable error messages for automation and CI.
  • Include multiple output formats (JSON, table, plain) and let users set defaults in config files.

Example use cases

  • Generate an oclif-based Node CLI that wraps SDK calls and provides login/logout/status flows.
  • Create a Go cobra CLI for a cloud service with bash/zsh completions and a plugin registry.
  • Add interactive wizards and progress bars to an existing CLI to simplify onboarding and long-running operations.
  • Build a multi-format output layer so the same CLI can be used in scripts (JSON) and interactively (table/plain).
  • Implement a plugin system that allows third parties to extend commands without modifying core code.

FAQ

Which frameworks do you target?

I map designs to common frameworks: oclif (Node), cobra (Go), click/typer (Python), and clap (Rust). I provide idiomatic code and files for the chosen framework.

How do you handle authentication in CLIs?

I design interactive login flows and token storage in config files, plus non-interactive options via environment variables or CI secrets. I include refresh logic and secure storage recommendations.