# How to Submit Code Reviews to GitLab Merge Requests via glab in tuicr

> Learn how to submit GitLab code reviews directly from your terminal using tuicr and glab. Effortlessly map inline comments to glab mr comment or glab api commands with the GitLabGlabBackend.

- Repository: [Almog Gavra/tuicr](https://github.com/agavra/tuicr)
- Tags: how-to-guide
- Published: 2026-08-07

---

**You submit code reviews to GitLab merge requests via glab by using tuicr's `GitLabGlabBackend`, which maps your inline comments to `glab mr comment` or `glab api` commands after you trigger the `:submit` action in the TUI.**

The **tuicr** repository implements a modular forge backend system that treats GitLab as a first-class citizen. When you need to submit code reviews to GitLab merge requests via glab, the application delegates all GitLab-specific operations to the `GitLabGlabBackend` struct defined in [`src/forge/gitlab/glab.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/gitlab/glab.rs), wrapping the official `glab` CLI tool to ensure compatibility with both GitLab.com and self-hosted instances.

## Understanding the Forge Backend Architecture

tuicr abstracts code review platforms through the **`ForgeBackend`** trait defined in [`src/forge/traits.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/traits.rs). This contract requires implementations to handle three core responsibilities: listing merge requests, fetching diffs, and submitting reviews.

For GitLab integration, the **`GitLabGlabBackend`** struct in [`src/forge/gitlab/glab.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/gitlab/glab.rs) fulfills this contract by shelling out to the `glab` binary rather than using a library API. This design ensures that authentication, rate limiting, and API versioning are managed by the official CLI tool already installed on your system.

The backend implements four critical methods:

- **`list_pull_requests`** (lines 50-66 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)): Executes `glab mr list --repo <repo> … --output json` and deserializes the JSON into `PullRequestSummary` objects.
- **`get_pull_request`** (lines 84-95 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)): Runs `glab mr view <id> --repo <repo> --output json` to construct `PullRequestDetails`.
- **`get_pull_request_diff`** (after line 400 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)): Retrieves the unified diff via `glab mr diff <id> --repo <repo>`.
- **`create_review`**: Maps internal comment structures to GitLab's API requirements, ultimately invoking either `glab mr comment` for single notes or `glab api` for bulk submissions (implemented in [`src/forge/submit.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/submit.rs)).

## The Code Review Submission Pipeline

Submitting a review follows a four-stage pipeline that transforms your TUI interactions into authenticated GitLab API calls.

### Remote Detection and Backend Initialization

When you launch tuicr from a repository directory, the **`detect_vcs`** function (located in [`src/forge/mod.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/mod.rs)) identifies the version control system and extracts the remote URL. The **`parse_any_remote_url`** function then recognizes GitLab URLs and instantiates a `GitLabGlabBackend`, configuring it with the appropriate repository identifier.

For self-hosted GitLab instances, the backend constructs full URLs using the **`repo_arg`** helper (lines 21-26 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)), ensuring the `--repo` flag receives the complete path (`https://<host>/<owner>/<repo>`).

### Fetching Merge Request Details

Opening a specific merge request triggers the data fetching phase. The backend calls **`get_pull_request`** to retrieve metadata and **`get_pull_request_diff`** to obtain the patch text. These operations use `glab`'s JSON output mode to ensure structured data parsing, with the response models defined in [`src/forge/gitlab/models.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/gitlab/models.rs) (structs like `GlabMrSummary` and `GlabMrDetails`).

### Creating and Storing Comments

As you navigate the diff in the TUI (rendered by [`src/ui/app_layout.rs`](https://github.com/agavra/tuicr/blob/main/src/ui/app_layout.rs)), pressing `i` initiates inline comment mode. Your text is stored in an in-memory **`ReviewSession`** struct (defined in [`src/model/review.rs`](https://github.com/agavra/tuicr/blob/main/src/model/review.rs)) which maintains a collection of `Comment` objects with file paths and line numbers. Pressing `Ctrl+S` persists these to the session without yet transmitting them to GitLab.

### Submitting via glab

When you execute the `:submit` command (handled in [`src/ui/app_layout.rs`](https://github.com/agavra/tuicr/blob/main/src/ui/app_layout.rs)), control passes to **[`src/forge/submit.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/submit.rs)**. This generic submission logic iterates over your `ReviewSession` comments and invokes **`create_review`** on the backend.

The `GitLabGlabBackend` translates each comment into a *position-aware* GitLab anchor comprising `file`, `line`, and `position` parameters. For single comments, it executes:

```bash
glab mr comment 42 \
    --repo owner/repo \
    --position file_path:line \
    --body "Your comment text"

```

For reviews containing multiple inline comments, the backend batches them using **`glab api`** with a constructed JSON payload. The **`run_api`** helper method (lines 39-45 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)) handles the HTTP POST operation, ensuring atomic submission of complex reviews.

## Practical Implementation Examples

The following workflows demonstrate how to submit code reviews to GitLab merge requests via glab using tuicr.

### Prerequisites: Authentication

Ensure `glab` is installed and authenticated before starting tuicr:

```bash

# Install glab

curl -s https://glab.rocks/install.sh | bash

# Authenticate (stores token in ~/.config/glab)

glab auth login

```

### Interactive TUI Workflow

Navigate to your repository and open a specific merge request:

```bash

# Open MR #42 in the tuicr TUI

tuicr pr open 42

```

Inside the interface:

1. Navigate to the target line and press `i` to insert a comment.
2. Type your feedback and press `Ctrl+S` to save the draft.
3. Press `:` to enter command mode, type `submit`, and confirm.

tuicr automatically invokes the appropriate `glab` commands based on your backend configuration, displaying the submission status in the UI.

### Non-Interactive CLI Workflow

For automation or scripting, use the review CLI commands:

```bash

# Add a line-specific comment without opening the TUI

tuicr review add --repo . --type line \
    --file src/lib.rs --line 128 \
    --message "Consider extracting this constant."

# Submit all pending comments

tuicr review submit --repo .

```

Both commands ultimately reach the same `GitLabGlabBackend::create_review` code path, ensuring consistent behavior between interactive and batch modes.

## Key Implementation Details

Understanding the internal mechanics helps debug submission failures and optimize review workflows.

**Position-Aware Anchoring**: GitLab requires precise positioning data for diff comments. The backend in [`src/forge/submit.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/submit.rs) calculates the correct `position` parameter (indicating whether the comment applies to the old or new version of a line) before invoking `glab`.

**Self-Hosted Support**: The `repo_arg` method automatically detects non-standard GitLab hosts from your Git remote configuration. If your remote URL points to `gitlab.company.com`, tuicr constructs the full repository path for the `--repo` flag without requiring manual configuration.

**Bulk Submission**: When a review contains more than one comment, tuicr bypasses individual `glab mr comment` calls in favor of `glab api` with a JSON array. This reduces API round-trips and ensures that either all comments succeed or all fail together, maintaining review integrity.

## Summary

- **tuicr** submits code reviews to GitLab merge requests via glab through the `GitLabGlabBackend` implementation in [`src/forge/gitlab/glab.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/gitlab/glab.rs).
- The **`ForgeBackend`** trait in [`src/forge/traits.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/traits.rs) abstracts platform differences, requiring implementations to handle listing, fetching, and creating reviews.
- Comments are stored in a **`ReviewSession`** (defined in [`src/model/review.rs`](https://github.com/agavra/tuicr/blob/main/src/model/review.rs)) during editing, then mapped to `glab mr comment` or `glab api` calls upon submission.
- The **`run_api`** method (lines 39-45 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)) handles bulk submissions, while single comments use the higher-level `glab mr comment` CLI interface.
- Self-hosted GitLab instances are supported automatically via the **`repo_arg`** helper (lines 21-26), which constructs full repository URLs from Git remotes.

## Frequently Asked Questions

### What authentication does tuicr require to submit GitLab reviews?

tuicr relies entirely on the `glab` CLI's authentication state. You must run `glab auth login` once to store an OAuth token in `~/.config/glab`. tuicr inherits these credentials automatically; it does not manage tokens independently or support token injection via environment variables.

### How does tuicr handle line positioning for multi-line comments?

The [`src/forge/submit.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/submit.rs) module calculates GitLab's required positioning parameters by comparing the comment's line number against the diff hunks stored in the `ReviewSession`. For each comment, it determines whether the anchor refers to the base or head version of the file, then passes this as the `position` argument to `glab mr comment` or includes it in the JSON payload for `glab api`.

### Can I use tuicr with self-hosted GitLab Enterprise Edition?

Yes. The `GitLabGlabBackend` detects self-hosted instances during the `detect_vcs` phase by parsing the remote URL. The `repo_arg` method (lines 21-26 of [`glab.rs`](https://github.com/agavra/tuicr/blob/main/glab.rs)) constructs the full repository identifier (`https://<host>/<owner>/<repo>`) required by `glab`, ensuring compatibility with private GitLab deployments without additional configuration.

### Why does tuicr use the glab CLI instead of a Rust GitLab library?

The implementation in [`src/forge/gitlab/glab.rs`](https://github.com/agavra/tuicr/blob/main/src/forge/gitlab/glab.rs) wraps the `glab` binary to delegate authentication, API versioning, and rate limiting to the officially maintained CLI tool. This reduces maintenance burden in tuicr and ensures that users benefit from `glab`'s built-in token management and enterprise-specific features without requiring Rust-native GitLab API bindings.