home / skills / openclaw / skills / glab-cli

glab-cli skill

/skills/portavion/glab-cli

This skill helps you manage GitLab projects with the glab CLI, improving merge requests, pipelines, issues, and releases across instances.

npx playbooks add skill openclaw/skills --skill glab-cli

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

Files (2)
skill.md
2.9 KB
---
name: glab
description: Interact with GitLab using the `glab` CLI. Use when Claude needs to work with GitLab merge requests, CI/CD pipelines, issues, releases, or make API requests. Supports gitlab.com and self-hosted instances.
---

# GitLab Skill

Use the `glab` CLI to interact with GitLab. Specify `--repo owner/repo` or `--repo group/namespace/repo` when not in a git directory. Also accepts full URLs.

## Merge Requests

List open merge requests:

```bash
glab mr list --repo owner/repo
```

View MR details:

```bash
glab mr view 55 --repo owner/repo
```

Create an MR from current branch:

```bash
glab mr create --fill --target-branch main
```

Approve, merge, or check out:

```bash
glab mr approve 55
glab mr merge 55
glab mr checkout 55
```

View MR diff:

```bash
glab mr diff 55
```

## CI/CD Pipelines

Check pipeline status for current branch:

```bash
glab ci status
```

View pipeline interactively (navigate jobs, view logs):

```bash
glab ci view
```

List recent pipelines:

```bash
glab ci list --repo owner/repo
```

Trace job logs in real time:

```bash
glab ci trace
glab ci trace 224356863  # specific job ID
glab ci trace lint       # by job name
```

Retry a failed pipeline:

```bash
glab ci retry
```

Validate `.gitlab-ci.yml`:

```bash
glab ci lint
```

## Issues

List and view issues:

```bash
glab issue list --repo owner/repo
glab issue view 42
```

Create an issue:

```bash
glab issue create --title "Bug report" --label bug
```

Add a comment:

```bash
glab issue note 42 -m "This is fixed in !55"
```

## API for Advanced Queries

Use `glab api` for endpoints not covered by subcommands. Supports REST and GraphQL.

Get project releases:

```bash
glab api projects/:fullpath/releases
```

Get MR with specific fields (pipe to jq):

```bash
glab api projects/owner/repo/merge_requests/55 | jq '.title, .state, .author.username'
```

Paginate through all issues:

```bash
glab api issues --paginate
```

GraphQL query:

```bash
glab api graphql -f query='
  query {
    currentUser { username }
  }
'
```

## JSON Output

Pipe to `jq` for filtering:

```bash
glab mr list --repo owner/repo | jq -r '.[] | "\(.iid): \(.title)"'
```

## Variables and Releases

Manage CI/CD variables:

```bash
glab variable list
glab variable set MY_VAR "value"
glab variable get MY_VAR
```

Create a release:

```bash
glab release create v1.0.0 --notes "Release notes here"
```

## Key Differences from GitHub CLI

| Concept                   | GitHub (`gh`) | GitLab (`glab`)                        |
| ------------------------- | ------------- | -------------------------------------- |
| Pull/Merge Request        | `gh pr`       | `glab mr`                              |
| CI runs                   | `gh run`      | `glab ci`                              |
| Repo path format          | `owner/repo`  | `owner/repo` or `group/namespace/repo` |
| Interactive pipeline view | N/A           | `glab ci view`                         |

Overview

This skill lets Claude interact with GitLab through the glab CLI to manage merge requests, CI/CD pipelines, issues, releases, and low-level API calls. It supports both gitlab.com and self-hosted instances and accepts repo shorthand, full paths, or URLs. Use it to automate common GitLab workflows from the command line or to run advanced queries and scripts.

How this skill works

The skill issues glab commands to list, view, create, approve, merge, and checkout merge requests; inspect and trace CI/CD pipelines and job logs; and list, create, and comment on issues. For endpoints not covered by subcommands it runs glab api for REST or GraphQL queries and emits JSON output that can be filtered with jq. It also manages CI variables and creates releases.

When to use it

  • Create, review, approve, or merge GitLab merge requests from a script or assistant workflow.
  • Inspect or trace CI/CD pipelines and job logs interactively or in automated runs.
  • Query GitLab data not covered by subcommands using REST or GraphQL via glab api.
  • Create or update issues, post comments, and automate issue workflows.
  • Manage project variables and create/releases programmatically.

Best practices

  • Specify --repo owner/repo or full group/namespace/repo when not in a git repo to avoid ambiguity.
  • Pipe JSON output to jq for precise filtering and integration into scripts.
  • Use glab ci view and glab ci trace for interactive troubleshooting rather than raw logs.
  • Use glab api with --paginate for large result sets to avoid truncated results.
  • Keep authentication tokens and CI variables secure; prefer project/group-level variables for automation.

Example use cases

  • List open merge requests and show titles: glab mr list --repo owner/repo | jq -r '.[] | "\(.iid): \(.title)"'
  • Create a merge request from current branch and target main: glab mr create --fill --target-branch main
  • Trace a failing job in real time: glab ci trace <job-id> or glab ci trace lint
  • Validate CI config and retry failed pipeline: glab ci lint && glab ci retry
  • Run a GraphQL query for current user: glab api graphql -f query='query { currentUser { username } }'

FAQ

Can glab work with self-hosted GitLab?

Yes. glab supports gitlab.com and self-hosted instances; point it to your instance or set the GITLAB_HOST configuration.

How do I get structured output for scripting?

Use glab subcommands that emit JSON and pipe to jq for filtering. Many glab commands support a --json flag or return JSON by default for api calls.