vince-winkintel/gitlab-cli-skills

glab-completion

Generate shell completion scripts for bash, zsh, fish, or PowerShell. Use when setting up glab autocompletion for your shell. Triggers on completion, autocomplete, shell completion, tab completion.

First seen Jun 22, 2026

Installation

$ npx skills add vince-winkintel/gitlab-cli-skills --skill glab-completion

Similar popular skills

Related neighbors and high-traction skills in the same topics — useful to compare before installing.

Also in this package

Other skills from vince-winkintel/gitlab-cli-skills · top by installs.

npx skills add vince-winkintel/gitlab-cli-skills

Browse all from vince-winkintel/gitlab-cli-skills

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Repository health

Stars 47
License LICENSE
Default branch main
Open issues 0
Status Active

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 11,172 B
  • docs SUMMARY.md 220 B

History

  1. First seen on skills.sh
  2. First recorded snapshot · 61 installs

SKILL.md

glab completion

Overview


  This command outputs code meant to be saved to a file, or immediately                                                 
  evaluated by an interactive shell. To load completions:                                                               
                                                                                                                        
  ### Bash                                                                                                              
                                                                                                                        
  To load completions in your current shell session:                                                                    
                                                                                                                        
  ```shell                                                                                                              
  source <(glab completion -s bash)                                                                                     
  ```                                                                                                                   
                                                                                                                        
  To load completions for every new session, run this command one time:                                                 
                                                                                                                        
  #### Linux                                                                                                            
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s bash > /etc/bash_completion.d/glab                                                                 
  ```                                                                                                                   
                                                                                                                        
  #### macOS                                                                                                            
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s bash > /usr/local/etc/bash_completion.d/glab                                                       
  ```                                                                                                                   
                                                                                                                        
  ### Zsh                                                                                                               
                                                                                                                        
  If shell completion is not already enabled in your environment you must                                               
  enable it. Run this command one time:                                                                                 
                                                                                                                        
  ```shell                                                                                                              
  echo "autoload -U compinit; compinit" >> ~/.zshrc                                                                     
  ```                                                                                                                   
                                                                                                                        
  To load completions in your current shell session:                                                                    
                                                                                                                        
  ```shell                                                                                                              
  source <(glab completion -s zsh); compdef _glab glab                                                                  
  ```                                                                                                                   
                                                                                                                        
  To load completions for every new session, run this command one time:                                                 
                                                                                                                        
  #### Linux                                                                                                            
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s zsh > "${fpath[1]}/_glab"                                                                          
  ```                                                                                                                   
                                                                                                                        
  #### macOS                                                                                                            
                                                                                                                        
  For older versions of macOS, you might need this command:                                                             
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s zsh > /usr/local/share/zsh/site-functions/_glab                                                    
  ```                                                                                                                   
                                                                                                                        
  The Homebrew version of glab should install completions automatically.                                                
                                                                                                                        
  ### fish                                                                                                              
                                                                                                                        
  To load completions in your current shell session:                                                                    
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s fish | source                                                                                      
  ```                                                                                                                   
                                                                                                                        
  To load completions for every new session, run this command one time:                                                 
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s fish > ~/.config/fish/completions/glab.fish                                                        
  ```                                                                                                                   
                                                                                                                        
  ### PowerShell                                                                                                        
                                                                                                                        
  To load completions in your current shell session:                                                                    
                                                                                                                        
  ```shell                                                                                                              
  glab completion -s powershell | Out-String | Invoke-Expression                                                        
  ```                                                                                                                   
                                                                                                                        
  To load completions for every new session, add the output of the above command                                        
  to your PowerShell profile.                                                                                           
                                                                                                                        
  When installing glab through a package manager, however, you might not need                                           
  more shell configuration to support completions.                                                                      
  For Homebrew, see [brew shell completion](https://docs.brew.sh/Shell-Completion)                                      
                                                                                                                        
         
  USAGE  
         
    glab completion [--flags]  
         
  FLAGS  
         
    -h --help   Show help for this command.
    --no-desc   Do not include shell completion description.
    -s --shell  Shell type: bash, zsh, fish, powershell. (bash)

Quick start

glab completion --help

Subcommands

This command has no subcommands.