/cli-ify --<platforms> command:<path-to-command>
/cli-ify --<platforms> skill:<skill-name>
/cli-ify --<platforms> agent:<agent-name>

/cli-ify --prompt "Description of what the CLI should do"

# Convert existing capabilities
/cli-ify --linux,windows command:fhb:update-readme
/cli-ify --linux skill:validating-pre-commit
/cli-ify --all skill:verifying-implementation

# Create from natural language
/cli-ify --prompt "Sync all git repos in a directory"
/cli-ify --prompt "Find and delete node_modules folders recursively"
/cli-ify --prompt "Convert images to WebP format in batch"

"Should this CLI [do X] or [do Y], or both? For Unix-style tools, each CLI should do one thing well."

"You mentioned [broad task]. Should we focus on just [specific subtask], or do you need the full scope?"

"This could be broken into: (a) [subtask1], (b) [subtask2]. Which is the priority, or should I create both?"

"What's the primary input: (a) directory path, (b) file list, (c) stdin, or (d) something else?"

"Should output be: (a) JSON for piping to other tools, (b) human-readable text, or (c) both (detect TTY)?"

"Should this modify files in place, or output to stdout/new files?"

"For errors, should the CLI: (a) stop immediately, (b) continue and report at end, or (c) user's choice via flag?"

"Should this require confirmation for destructive operations, or is --force / --dry-run enough?"

"What should happen if [edge case]?"

"Does this need any credentials or API keys? If so, from environment variables?"

"Should this work on both Linux/Mac and Windows, or just one platform?"

Your description includes multiple operations. Let's break this into atomic CLIs:

1. **find-git-repos**: Recursively find all git repositories in a directory
2. **git-sync**: Pull latest changes for a given git repository
3. **batch-git-sync**: Compose the above to sync multiple repos

Which should we create first? Or would you prefer a single composed script?

## Proposed CLI: `<name>`

**One-liner**: <clear description in one sentence>

**Inputs**:
- Arg 1: <description>
- Option --<flag>: <description>

**Processing**:
1. <step 1>
2. <step 2>

**Outputs**:
- stdout: <what it outputs>
- Exit 0: success
- Exit 1: <error condition>

**Does NOT do** (scope boundaries):
- <thing that's out of scope>
- <thing that would require separate CLI>

Shall I proceed with this specification?

## Proposed CLI: `git-sync-repos`

**One-liner**: Pull latest changes for all git repositories in a directory tree

**Inputs**:
- Arg 1 (optional): Target directory (default: current directory)
- --json: Output JSON summary instead of progress text
- --include-dirty: Attempt to pull repos with uncommitted changes (default: skip)

**Processing**:
1. Find all directories containing .git folder
2. For each, check for uncommitted changes
3. If clean (or --include-dirty), run git pull
4. Collect results

**Outputs**:
- stdout: Progress messages or JSON summary
- Exit 0: All repos synced successfully
- Exit 1: One or more repos failed

**Does NOT do**:
- Branch switching
- Stashing uncommitted changes
- Handling merge conflicts

Shall I proceed with this specification?

# Parse examples
/cli-ify --linux,windows command:fhb:update-readme
# → Platforms: [linux, windows]
# → Source type: command
# → Source path: fhb:update-readme → ~/.claude/commands/fhb/update-readme.md

/cli-ify --all skill:validating-pre-commit
# → Platforms: [linux, windows]
# → Source type: skill
# → Source path: validating-pre-commit → ~/.claude/skills/validating-pre-commit/SKILL.md

## CLI Suitability Assessment

**Source**: [command/skill/agent name]

**Core Operations**:
1. [What does it read/input?]
2. [What processing does it do?]
3. [What does it output?]

**Deterministic?**: Yes/No - Can output be predicted from inputs?
**Stateless?**: Yes/No - Does each run start fresh?
**CLI-able I/O?**: Yes/No - Can inputs come from args/stdin, outputs to stdout/files?
**Human-debuggable?**: Yes/No - Can a human understand and verify output?

**Verdict**: ✅ Good CLI candidate / ⚠️ Partial candidate / ❌ Not suitable

**If Not Suitable, Explain Why**:
[Clear explanation of why this should remain a Claude skill]

## Not Recommended for CLI Conversion

**Source**: [name]

**Reason**: This capability relies on [specific Claude feature] which cannot be replicated in a standalone CLI:
- [Reason 1]
- [Reason 2]

**Recommendation**: Keep this as a [command/skill/agent] and invoke via Claude Code.

**Alternative**: If you need automation, consider:
- Using `claude --dangerously-skip-permissions` in scripts
- Creating a wrapper script that calls Claude with this skill
- Extracting only the [specific subset] that IS CLI-suitable

## Extracted Operations

1. **Operation**: [name]
   - Input: [what it reads]
   - Process: [what it does]
   - Output: [what it produces]
   - Exit codes: 0=success, 1=failure, 2=...

2. **Operation**: [name]
   ...

script-name <subcommand> [options] [arguments]

Subcommands:
  list        - List resources
  get <id>    - Get specific resource
  create      - Create new resource
  update <id> - Update existing resource
  delete <id> - Delete resource
  run         - Execute the main operation

#!/usr/bin/env bash
set -euo pipefail

# Configuration from environment
: "${CONFIG_VAR:=default_value}"

# Help text
show_help() {
    cat << 'EOF'
Usage: script-name <command> [options]

Commands:
    run         Execute main operation
    list        List resources
    help        Show this help

Options:
    -o, --output FORMAT   Output format (json|text)
    -v, --verbose         Verbose output
    -h, --help            Show help

Environment:
    CONFIG_VAR            Description of variable

Examples:
    script-name run --output json
    script-name list | jq '.[] | .name'
EOF
}

# Main logic
main() {
    local cmd="${1:-help}"
    shift || true

    case "$cmd" in
        run)    do_run "$@" ;;
        list)   do_list "$@" ;;
        help)   show_help ;;
        *)      echo "Unknown command: $cmd" >&2; exit 1 ;;
    esac
}

main "$@"

#Requires -Version 5.1
[CmdletBinding()]
param(
    [Parameter(Position=0)]
    [ValidateSet('run', 'list', 'help')]
    [string]$Command = 'help',

    [Parameter()]
    [ValidateSet('json', 'text')]
    [string]$OutputFormat = 'text',

    [Parameter()]
    [switch]$Verbose
)

# Configuration from environment
$ConfigVar = $env:CONFIG_VAR ?? 'default_value'

function Show-Help {
    @"
Usage: script-name.ps1 <command> [options]

Commands:
    run         Execute main operation
    list        List resources
    help        Show this help

Options:
    -OutputFormat   Output format (json|text)
    -Verbose        Verbose output

Environment:
    CONFIG_VAR      Description of variable

Examples:
    .\script-name.ps1 run -OutputFormat json
    .\script-name.ps1 list | ConvertFrom-Json | Select-Object name
"@
}

# Main logic
switch ($Command) {
    'run'  { Invoke-Run }
    'list' { Invoke-List }
    'help' { Show-Help }
    default { Write-Error "Unknown command: $Command"; exit 1 }
}

~/.claude/skills/<source-skill>/scripts/
    ├── <name>.sh          # Bash version
    └── <name>.ps1         # PowerShell version

# For commands, create a scripts directory:
~/.claude/commands/<path>/scripts/
    ├── <name>.sh
    └── <name>.ps1

~/.local/bin/<name>              # Symlink or direct
# or
~/bin/<name>                     # User bin directory
# or create a dedicated location:
~/.claude/cli-tools/
    ├── <name>.sh
    └── <name>.ps1

chmod +x <script-path>/*.sh

# CLI: <name>

<One-liner description>

## Installation

### Linux/Mac
\`\`\`bash
# Add to PATH or symlink
ln -s <script-path>/<name>.sh ~/.local/bin/<name>
\`\`\`

### Windows (PowerShell)
\`\`\`powershell
# Add to PATH or create alias
Set-Alias -Name <name> -Value "<script-path>\<name>.ps1"
\`\`\`

## Usage

\`\`\`bash
# Show help
<name> help

# Run main operation
<name> run [options]
\`\`\`

## Exit Codes

- 0: Success
- 1: General error
- 2: Invalid arguments
- 3: Missing dependencies

## Examples

### Human usage
\`\`\`bash
<name> run --output json | jq '.items | length'
\`\`\`

### Scripting
\`\`\`bash
for item in $(<name> list --format ids); do
    <name> process "$item"
done
\`\`\`

# Check syntax
bash -n script.sh
pwsh -NoExecute -File script.ps1

# Check help works
./script.sh help
.\script.ps1 help

# Test basic operation
./script.sh run --help

git-sync-repos [directory] [--json] [--include-dirty]
git-sync-repos ~/projects           # Sync all repos in ~/projects
git-sync-repos --json               # Output JSON summary

pre-commit-validate run       # Run all validations
pre-commit-validate python    # Python only
pre-commit-validate typescript # TypeScript only
pre-commit-validate --major   # Include implementation check