Command Optimization

This skill specializes in creating, designing, and optimizing command-line interfaces. It focuses on command design patterns, argument parsing, task automation, and CLI best practices.

When to Use This Skill

• When creating new CLI commands

• When designing command interfaces

• When optimizing existing commands

• When implementing argument parsing

• When automating tasks via CLI

• When improving command user experience

What This Skill Does

• Command Design: Creates well-structured CLI commands

• Argument Parsing: Designs intuitive argument and option structures

• Task Automation: Automates repetitive tasks through commands

• User Experience: Improves command usability and feedback

• Error Handling: Implements robust error handling and validation

• Documentation: Creates clear command documentation and help text

How to Use

Create Command

Create a command to generate React components

Design a CLI command for database migrations

Optimize Command

Improve the user experience of this command

Command Design Patterns

Task-Oriented Commands

Structure:

• Clear action verb (generate, create, build)

• Target object (component, migration, test)

• Options for customization

• Helpful output and feedback

Example:

Good: Clear and actionable

npm run generate:component UserProfile

Bad: Unclear purpose

npm run make UserProfile

Analysis Commands

Structure:

• Analysis type (analyze, check, audit)

• Target to analyze

• Output format options

• Actionable recommendations

Example:

Good: Clear analysis command

npm run analyze:dependencies -- --outdated

Bad: Vague command

npm run check

Argument Handling

File/Directory Arguments

Pattern:

• Accept single file or directory

• Support glob patterns

• Validate existence

• Handle permissions

Example:

Single file

lint src/utils.js

Directory

lint src/

Glob pattern

lint "src/**/*.js"

Configuration Options

Common Options:

• --config : Custom configuration file

• --output : Output directory or format

• --verbose : Detailed logging

• --dry-run : Preview without execution

• --force : Override safety checks

Error Handling

Input Validation

Check:

• File/directory existence

• Read/write permissions

• File format validity

• Required dependencies

• Configuration syntax

Error Messages

Good Error Messages:

• Clear description of the problem

• Specific location (file, line)

• Suggested fix

• Context about why it failed

Example:

Good

Error: Configuration file not found: .eslintrc.json Run 'npm run init:config' to create it.

Bad

Error: File not found

Examples

Example 1: Component Generator Command

Input: Create a command to generate React components

Output:

Command: generate:component

Usage

npm run generate:component ComponentName [options]

Options

- --path <path>
: Output path (default: src/components)

- --type <type>
: Component type (functional|class) (default: functional)

- --with-tests
: Generate test file

- --with-styles
: Generate stylesheet

Examples

# Basic component
npm run generate:component UserCard

# With options
npm run generate:component UserCard --path src/features/users --with-tests --with-styles

Implementation

// scripts/generate-component.js
const componentName = process.argv[2];
const options = parseArgs(process.argv.slice(3));

if (!componentName) {
  console.error('Error: Component name required');
  console.log('Usage: npm run generate:component <Name>');
  process.exit(1);
}

generateComponent(componentName, options);

Example 2: Database Migration Command

Input: Create a database migration command

Output:

## Command: db:migrate

### Usage
```bash
npm run db:migrate [migration-name] [options]

Options

- --create <table>
: Create new migration for table

- --rollback
: Rollback last migration

- --status
: Show migration status

- --to <version>
: Migrate to specific version

Examples

# Create migration
npm run db:migrate --create users

# Run migrations
npm run db:migrate

# Check status
npm run db:migrate --status

# Rollback
npm run db:migrate --rollback

## Reference Files

- **`references/SLASH_COMMAND.template.md`** - Slash command template with frontmatter, dynamic context, and workflow structure

## Best Practices

### Command Design

1. **Clear Names**: Use descriptive, action-oriented names
2. **Consistent Patterns**: Follow project conventions
3. **Helpful Defaults**: Sensible defaults for common use cases
4. **Good Feedback**: Clear output and progress indicators
5. **Error Handling**: Graceful failure with helpful messages

### User Experience

- **Progressive Disclosure**: Show basic usage, advanced options in help
- **Validation**: Validate inputs early with clear errors
- **Confirmation**: Ask for confirmation on destructive operations
- **Dry Run**: Support --dry-run for preview
- **Verbose Mode**: --verbose for detailed output

### Documentation

- **Help Text**: Clear, concise help for each command
- **Examples**: Include practical examples
- **Error Messages**: Explain what went wrong and how to fix
- **README**: Document commands in project README

## Related Use Cases

- Creating project-specific commands
- Automating development tasks
- Building CLI tools
- Improving command usability
- Standardizing command patterns