gitlab-skill 1.0.0

package/GITLAB_API_COMPREHENSIVE_GUIDE.md

@@ -0,0 +1,3885 @@
+# GitLab API & CLI - Guía Completa Operativa
+
+> **Fecha de recopilación**: 18 de febrero de 2026
+> **Fuentes**: Documentación oficial de GitLab Docs
+> **Enfoque**: Ejemplos prácticos y operativos sin UI web
+
+---
+
+## Tabla de Contenidos
+
+1. [Resumen por URL](#resumen-por-url)
+2. [Patrones de Uso Recomendados](#patrones-de-uso-recomendados)
+3. [Ejemplos Concretos por Features (25+)](#ejemplos-concretos-por-features)
+4. [Troubleshooting y Códigos HTTP](#troubleshooting-y-códigos-http)
+5. [Estructura Modular Recomendada](#estructura-modular-recomendada)
+
+---
+
+## Resumen por URL
+
+### 1. GraphQL API (`/api/graphql/`)
+
+**Puntos clave accionables:**
+
+- **Endpoint único**: `/api/graphql` - API versionless (sin versiones)
+- **Autenticación**: OAuth 2.0, Personal/Project/Group access tokens, Session cookie
+- **Headers de autenticación**: `Authorization: Bearer <token>` (recomendado) o `private_token` parameter
+- **Scopes requeridos**: `api` (read-write) o `read_api` (read-only)
+- **Límites**:
+  - Complejidad máxima: 200 (no autenticado), 250 (autenticado)
+  - Tamaño máximo de query: 10,000 caracteres
+  - Paginación: max 100 registros por página
+  - Blobs: límite de 20 MB para múltiples blobs
+  - Timeout: 30 segundos
+- **Identificadores**: Global IDs (`gid://gitlab/Issue/123`), full paths, IIDs
+- **Multiplex**: Soporta batching de múltiples queries en una sola request
+- **Introspección**: Schemas estáticos disponibles en producción
+- **Breaking changes**: Deprecación de 6 releases antes de remover
+- **Testing futuro**: `?remove_deprecated=true` para verificar queries contra schema futuro
+
+**Ventajas operativas:**
+- Solicitar exactamente los datos necesarios (reduce requests)
+- Exploración interactiva con GraphiQL (`/-/graphql-explorer`)
+- Sin necesidad de parseo manual (client-side libraries)
+- Batching de queries para optimizar performance
+
+---
+
+### 2. GraphQL Reference (`/api/graphql/reference/`)
+
+**Puntos clave accionables:**
+
+- **Referencia completa**: Schema detallado con todos los types, fields, arguments
+- **Query type**: Entry points para todas las queries disponibles
+- **Mutation types**: Operaciones de creación, actualización, eliminación
+- **Deprecation markers**: Campos marcados como deprecated con alternativas
+- **Experiments**: Items experimentales pueden removerse sin aviso
+- **Feature flags**: Campos detrás de feature flags deshabilitados pueden removerse sin proceso de deprecación
+
+**Uso práctico:**
+- Consultar antes de implementar queries/mutations
+- Verificar tipos de datos y argumentos requeridos
+- Identificar campos deprecated para migrar código
+
+---
+
+### 3. GitLab CLI - glab (`/cli/`)
+
+**Puntos clave accionables:**
+
+- **Instalación**: Disponible para Linux, macOS, Windows (ver README)
+- **Autenticación**: `glab auth login` (OAuth o personal access token)
+- **Multi-instancia**: Soporta múltiples instancias autenticadas simultáneamente
+- **Auto-detección**: Detecta hostname desde remotes Git del directorio actual
+
+**Variables de entorno clave:**
+- `GITLAB_TOKEN`: Token de autenticación (evita prompts)
+- `GITLAB_HOST` / `GL_HOST`: URL del servidor GitLab (default: gitlab.com)
+- `GLAB_CONFIG_DIR`: Directorio de configuración personalizado
+- `NO_PROMPT`: Deshabilitar prompts interactivos
+- `DEBUG`: Habilitar logging detallado
+- `GLAB_ENABLE_CI_AUTOLOGIN`: Auto-login en CI/CD jobs (experimental)
+
+**Comandos principales:**
+- `glab api`: Llamadas directas a REST API
+- `glab mr`: Merge requests (create, list, view, checkout, approve, merge)
+- `glab issue`: Issues (create, list, view, close, reopen)
+- `glab ci`: Pipelines y jobs (view, trace, retry, cancel)
+- `glab repo`: Repositorios (clone, fork, view)
+- `glab release`: Releases (create, list, view, delete)
+- `glab variable`: Variables CI/CD (list, create, update, delete)
+
+**Ventajas operativas:**
+- Integración nativa con Git workflow
+- No requiere cambio de contexto (terminal)
+- Scripting y automatización fácil
+- GitLab Duo Chat desde CLI
+
+---
+
+### 4. REST API (`/api/rest/`)
+
+**Puntos clave accionables:**
+
+- **Endpoint base**: `https://gitlab.example.com/api/v4`
+- **Versión**: v4 (semantic versioning, major version)
+- **Formato**: JSON (algunos endpoints soportan plain text)
+- **Autenticación**: Personal/Project/Group access tokens, OAuth 2.0, Job tokens, Session cookie
+- **Headers recomendados**: `PRIVATE-TOKEN: <token>` o `Authorization: Bearer <token>`
+
+**Paginación:**
+
+**Offset-based (default):**
+- Parámetros: `page` (default: 1), `per_page` (default: 20, max: 100)
+- Headers de respuesta: `x-total`, `x-total-pages`, `x-page`, `x-per-page`, `x-next-page`, `x-prev-page`
+- Link header con `rel="next"`, `rel="prev"`, `rel="first"`, `rel="last"`
+- Límite: max offset configurable (performance)
+
+**Keyset-based (más eficiente):**
+- Parámetros: `pagination=keyset`, `order_by`, `sort`, `per_page`
+- Independiente del tamaño de la colección
+- Link header con cursor para siguiente página
+- Headers: `X-NEXT-CURSOR`, `X-PREV-CURSOR`
+- Recursos soportados: Projects, Users, Groups, Audit events, Jobs, Registry tags, etc.
+
+**Encoding:**
+- Namespaced paths: URL-encoded (`/` → `%2F`)
+- Ejemplo: `diaspora/diaspora` → `diaspora%2Fdiaspora`
+- File paths, branches, tags: URL-encoded
+- Arrays: `param[]=value1&param[]=value2`
+- Hashes: `param[key]=value`
+- ISO 8601 dates: `+` → `%2B` (ej: `2017-10-17T23:11:13.000%2B05:30`)
+
+**Rate limits:**
+- GitLab.com: Ver límites específicos en documentación
+- Self-managed: Configurables por instancia
+- Headers de respuesta indican límites y uso actual
+
+---
+
+### 5. OpenAPI Interactive (`/api/openapi/openapi_interactive/`)
+
+**Nota**: Esta URL no pudo ser accedida completamente, pero típicamente proporciona:
+- Interfaz Swagger/OpenAPI para explorar REST API
+- Testing interactivo de endpoints
+- Documentación generada automáticamente
+- Ejemplos de requests/responses
+
+---
+
+### 6. REST API Troubleshooting (`/api/rest/troubleshooting/`)
+
+**Puntos clave accionables:**
+
+**Códigos de estado HTTP:**
+
+| Código | Significado | Acción |
+|--------|-------------|--------|
+| `200 OK` | Éxito en GET/PUT/PATCH/DELETE | Recurso retornado como JSON |
+| `201 Created` | Éxito en POST | Recurso creado retornado como JSON |
+| `202 Accepted` | Aceptado para procesamiento | Recurso será procesado |
+| `204 No Content` | Éxito sin contenido | No hay payload en respuesta |
+| `301 Moved Permanently` | Recurso movido | Usar URL en header `Location` |
+| `304 Not Modified` | No modificado desde última request | Usar caché |
+| `400 Bad Request` | Atributo requerido faltante | Verificar parámetros |
+| `401 Unauthorized` | No autenticado | Proporcionar token válido |
+| `403 Forbidden` | No autorizado | Verificar permisos |
+| `404 Not Found` | Recurso no encontrado | Verificar ID/path |
+| `405 Method Not Allowed` | Método no soportado | Usar método correcto |
+| `409 Conflict` | Recurso conflictivo existe | Resolver conflicto |
+| `412 Precondition Failed` | Precondición falló | Verificar headers condicionales |
+| `422 Unprocessable` | Entidad no procesable | Verificar validación |
+| `429 Too Many Requests` | Rate limit excedido | Esperar y reintentar |
+| `500 Server Error` | Error interno del servidor | Reportar a administrador |
+| `503 Service Unavailable` | Servidor sobrecargado | Reintentar más tarde |
+
+**Error 400 - Validación:**
+
+Formato de error de validación:
+```json
+{
+  "message": {
+    "<property-name>": [
+      "<error-message>",
+      "<error-message>"
+    ],
+    "<embed-entity>": {
+      "<property-name>": [
+        "<error-message>"
+      ]
+    }
+  }
+}
+```
+
+**Debugging:**
+- Incluir headers: `curl --include` (muestra headers HTTP)
+- Incluir exit code: `curl --fail` (muestra código de salida)
+- Verbose: `curl --verbose` (debug completo)
+
+**Spam detection:**
+
+Sin CAPTCHA:
+```json
+{"message":{"error":"Your snippet has been recognized as spam and has been discarded."}}
+```
+
+Con CAPTCHA:
+```json
+{
+  "needs_captcha_response": true,
+  "spam_log_id": 42,
+  "captcha_site_key": "REDACTED",
+  "message": {"error": "Your snippet has been recognized as spam..."}
+}
+```
+
+Resolución:
+1. Obtener CAPTCHA response con `captcha_site_key` (Google reCAPTCHA v2)
+2. Reenviar con headers: `X-GitLab-Captcha-Response`, `X-GitLab-Spam-Log-Id`
+
+**Error 404 con reverse proxy:**
+- Problema: Proxy decodifica caracteres URL-encoded antes de pasar a GitLab
+- Solución Apache: Agregar `AllowEncodedSlashes NoDecode` y `nocanon` flag en `ProxyPass`
+- Solución NGINX: Configurar `proxy_pass` sin decodificación automática
+
+---
+
+### 7. GraphQL Examples (`/api/graphql/examples/`)
+
+**Puntos clave accionables:**
+
+**Métodos de ejecución:**
+1. **GraphiQL** (más fácil): `https://gitlab.com/-/graphql-explorer` o `https://<instance>/-/graphql-explorer`
+2. **Command line**: `curl` con POST a `/api/graphql`
+3. **Rails console**: Para self-managed/dedicated
+
+**Estructura básica de query:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    id
+    name
+    issues {
+      nodes {
+        title
+        description
+      }
+    }
+  }
+}
+```
+
+**Estructura básica de mutation:**
+```graphql
+mutation {
+  createNote(input: {
+    noteableId: "gid://gitlab/Issue/123",
+    body: "Comentario"
+  }) {
+    note {
+      id
+      body
+    }
+    errors
+  }
+}
+```
+
+**Patterns importantes:**
+- Siempre incluir `errors` en mutations
+- Usar `nodes { }` para colecciones (sintaxis corta)
+- Usar `edges { node { } }` cuando necesitas cursor para paginación
+- Paginación: `first`, `last`, `after`, `before`, `endCursor`, `hasNextPage`
+- Sorting: Usar argumentos `sort` donde disponible (ej: `issues(sort: created_asc)`)
+- Introspección: `queryComplexity { score limit }` para verificar complejidad
+
+**Ejemplos documentados:**
+- Audit reports
+- Issue boards
+- Query users
+- Custom emoji
+- Branch rules
+- Work items
+
+---
+
+## Patrones de Uso Recomendados
+
+### Autenticación
+
+**REST API:**
+
+```bash
+# Método 1: Header (recomendado)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects"
+
+# Método 2: Bearer token (OAuth-compliant)
+curl --header "Authorization: Bearer <token>" \
+  --url "https://gitlab.example.com/api/v4/projects"
+
+# Método 3: Query parameter (menos seguro)
+curl --url "https://gitlab.example.com/api/v4/projects?private_token=<token>"
+
+# Job token (CI/CD)
+curl --header "JOB-TOKEN: $CI_JOB_TOKEN" \
+  --url "https://gitlab.example.com/api/v4/projects/1/releases"
+```
+
+**GraphQL API:**
+
+```bash
+# Header (recomendado)
+curl --request POST \
+  --header "Authorization: Bearer $GRAPHQL_TOKEN" \
+  --header "Content-Type: application/json" \
+  --data '{"query": "query {currentUser {name}}"}' \
+  --url "https://gitlab.com/api/graphql"
+
+# Query parameter
+curl --request POST \
+  --header "Content-Type: application/json" \
+  --data '{"query": "query {currentUser {name}}"}' \
+  --url "https://gitlab.com/api/graphql?private_token=<token>"
+```
+
+**glab CLI:**
+
+```bash
+# Autenticación interactiva
+glab auth login
+
+# Variable de entorno
+export GITLAB_TOKEN="<token>"
+glab api projects
+
+# Archivo de configuración
+glab config set token <token>
+```
+
+---
+
+### Paginación
+
+**REST - Offset-based:**
+
+```bash
+# Página 2, 50 items por página
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects?page=2&per_page=50"
+
+# Usar Link header para siguiente página
+# Link: <https://gitlab.example.com/api/v4/projects?page=3&per_page=50>; rel="next"
+```
+
+**REST - Keyset-based (más eficiente):**
+
+```bash
+# Primera página
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects?pagination=keyset&per_page=50&order_by=id&sort=asc"
+
+# Siguiente página (usar cursor del Link header)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects?pagination=keyset&per_page=50&order_by=id&sort=asc&id_after=42"
+```
+
+**GraphQL:**
+
+```graphql
+# Primera página
+query {
+  project(fullPath: "grupo/proyecto") {
+    issues(first: 10) {
+      edges {
+        node {
+          title
+        }
+        cursor
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+    }
+  }
+}
+
+# Siguiente página (usar endCursor)
+query {
+  project(fullPath: "grupo/proyecto") {
+    issues(first: 10, after: "eyJpZCI6IjI3MDM4OTMzIn0") {
+      edges {
+        node {
+          title
+        }
+        cursor
+      }
+      pageInfo {
+        endCursor
+        hasNextPage
+      }
+    }
+  }
+}
+```
+
+---
+
+### Manejo de Errores
+
+**REST API:**
+
+```bash
+# Capturar código de estado
+HTTP_CODE=$(curl --write-out '%{http_code}' --silent --output /dev/null \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123")
+
+if [ "$HTTP_CODE" -eq 200 ]; then
+  echo "Success"
+elif [ "$HTTP_CODE" -eq 404 ]; then
+  echo "Project not found"
+elif [ "$HTTP_CODE" -eq 401 ]; then
+  echo "Unauthorized - check token"
+elif [ "$HTTP_CODE" -eq 429 ]; then
+  echo "Rate limit exceeded - wait and retry"
+fi
+
+# Incluir headers para debugging
+curl --include --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+```
+
+**GraphQL API:**
+
+```bash
+# GraphQL siempre retorna 200, verificar errors en response
+RESPONSE=$(curl --request POST \
+  --header "Authorization: Bearer $TOKEN" \
+  --header "Content-Type: application/json" \
+  --data '{"query": "query {project(fullPath: \"invalid\") {id}}"}' \
+  --url "https://gitlab.com/api/graphql")
+
+# Verificar si hay errores
+if echo "$RESPONSE" | jq -e '.errors' > /dev/null; then
+  echo "GraphQL errors found:"
+  echo "$RESPONSE" | jq '.errors'
+fi
+```
+
+**glab CLI:**
+
+```bash
+# glab retorna códigos de salida estándar
+if glab api projects/123 > /dev/null 2>&1; then
+  echo "Project exists"
+else
+  echo "Project not found or error: $?"
+fi
+
+# Capturar output y errores
+OUTPUT=$(glab api projects/123 2>&1)
+if [ $? -ne 0 ]; then
+  echo "Error: $OUTPUT"
+fi
+```
+
+---
+
+### Rate Limits
+
+**Estrategias:**
+
+```bash
+# 1. Verificar headers de rate limit
+curl --include --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects" | grep -i "ratelimit"
+
+# 2. Implementar retry con backoff exponencial
+retry_with_backoff() {
+  local max_attempts=5
+  local timeout=1
+  local attempt=1
+  
+  while [ $attempt -le $max_attempts ]; do
+    HTTP_CODE=$(curl --write-out '%{http_code}' --silent --output response.json \
+      --header "PRIVATE-TOKEN: <token>" \
+      "$1")
+    
+    if [ "$HTTP_CODE" -eq 429 ]; then
+      echo "Rate limited, waiting ${timeout}s..."
+      sleep $timeout
+      timeout=$((timeout * 2))
+      attempt=$((attempt + 1))
+    elif [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+      cat response.json
+      return 0
+    else
+      echo "Error: HTTP $HTTP_CODE"
+      return 1
+    fi
+  done
+  
+  echo "Max retries exceeded"
+  return 1
+}
+
+# 3. Usar keyset pagination para grandes datasets
+# (más eficiente que offset pagination)
+
+# 4. Batch operations cuando sea posible
+# GraphQL multiplex:
+curl --request POST \
+  --header "Authorization: Bearer $TOKEN" \
+  --header "Content-Type: application/json" \
+  --data '[
+    {"query": "query {project(fullPath: \"grupo/proyecto1\") {id}}"},
+    {"query": "query {project(fullPath: \"grupo/proyecto2\") {id}}"}
+  ]' \
+  --url "https://gitlab.com/api/graphql"
+```
+
+---
+
+## Ejemplos Concretos por Features
+
+### 1. Projects
+
+#### REST API
+
+**Listar todos los proyectos:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects"
+```
+
+**Obtener proyecto específico:**
+```bash
+# Por ID
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+
+# Por path (URL-encoded)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/grupo%2Fproyecto"
+```
+
+**Crear proyecto:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name": "Mi Proyecto",
+    "path": "mi-proyecto",
+    "description": "Descripción del proyecto",
+    "visibility": "private",
+    "initialize_with_readme": true
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects"
+```
+
+**Actualizar configuración del proyecto:**
+```bash
+# Deshabilitar forking
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{"forking_access_level": "disabled"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+
+# Configurar CI/CD
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "builds_access_level": "enabled",
+    "auto_devops_enabled": true,
+    "auto_cancel_pending_pipelines": "enabled"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+```
+
+**Archivar/Desarchivar proyecto:**
+```bash
+# Archivar
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/archive"
+
+# Desarchivar
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/unarchive"
+```
+
+#### GraphQL API
+
+**Query proyecto con issues:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    id
+    name
+    description
+    visibility
+    webUrl
+    createdAt
+    issues(first: 10, state: OPENED) {
+      nodes {
+        iid
+        title
+        state
+        createdAt
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+}
+```
+
+**Mutation: Actualizar proyecto:**
+```graphql
+mutation {
+  updateProject(input: {
+    projectPath: "grupo/proyecto",
+    description: "Nueva descripción"
+  }) {
+    project {
+      id
+      description
+    }
+    errors
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar proyectos
+glab repo list
+
+# Ver proyecto actual
+glab repo view
+
+# Clonar proyecto
+glab repo clone grupo/proyecto
+
+# Fork proyecto
+glab repo fork grupo/proyecto
+
+# Archivar proyecto
+glab api --method POST projects/123/archive
+```
+
+---
+
+### 2. Groups
+
+#### REST API
+
+**Listar grupos:**
+```bash
+# Todos los grupos
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/groups"
+
+# Grupos con proyectos
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/groups?with_projects=true"
+```
+
+**Obtener grupo específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/groups/grupo-id"
+```
+
+**Crear grupo:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name": "Mi Grupo",
+    "path": "mi-grupo",
+    "description": "Descripción del grupo",
+    "visibility": "private"
+  }' \
+  --url "https://gitlab.example.com/api/v4/groups"
+```
+
+**Listar proyectos de un grupo:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/groups/grupo-id/projects"
+```
+
+#### GraphQL API
+
+**Query grupo con proyectos:**
+```graphql
+query {
+  group(fullPath: "mi-grupo") {
+    id
+    name
+    fullPath
+    projects {
+      nodes {
+        id
+        name
+        visibility
+      }
+    }
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar grupos
+glab api groups
+
+# Ver grupo específico
+glab api groups/grupo-id
+```
+
+---
+
+### 3. Issues
+
+#### REST API
+
+**Listar issues de un proyecto:**
+```bash
+# Todas las issues
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues"
+
+# Issues abiertas
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues?state=opened"
+
+# Issues con filtros
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues?labels=bug,critical&assignee_id=5"
+```
+
+**Obtener issue específica:**
+```bash
+# Por IID (internal ID)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues/42"
+```
+
+**Crear issue:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "title": "Bug en login",
+    "description": "El login no funciona con usuarios nuevos",
+    "labels": "bug,high-priority",
+    "assignee_ids": [5, 10]
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues"
+```
+
+**Actualizar issue:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "state_event": "close",
+    "labels": "bug,resolved"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues/42"
+```
+
+**Agregar comentario a issue:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "body": "Este issue ha sido resuelto en el commit abc123"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues/42/notes"
+```
+
+#### GraphQL API
+
+**Query issues con filtros:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    issues(
+      state: OPENED
+      labelName: ["bug", "critical"]
+      first: 20
+    ) {
+      nodes {
+        iid
+        title
+        description
+        state
+        labels {
+          nodes {
+            title
+          }
+        }
+        assignees {
+          nodes {
+            username
+          }
+        }
+        createdAt
+        updatedAt
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+}
+```
+
+**Mutation: Crear issue:**
+```graphql
+mutation {
+  createIssue(input: {
+    projectPath: "grupo/proyecto",
+    title: "Bug en login",
+    description: "El login no funciona con usuarios nuevos",
+    labelIds: ["gid://gitlab/Label/1", "gid://gitlab/Label/2"]
+  }) {
+    issue {
+      iid
+      title
+      webUrl
+    }
+    errors
+  }
+}
+```
+
+**Mutation: Cerrar issue:**
+```graphql
+mutation {
+  issueSetLocked(input: {
+    projectPath: "grupo/proyecto",
+    iid: "42",
+    locked: true
+  }) {
+    issue {
+      id
+      iid
+    }
+    errors
+  }
+}
+
+mutation {
+  updateIssue(input: {
+    projectPath: "grupo/proyecto",
+    iid: "42",
+    stateEvent: CLOSE
+  }) {
+    issue {
+      iid
+      state
+    }
+    errors
+  }
+}
+```
+
+**Mutation: Agregar comentario:**
+```graphql
+mutation {
+  createNote(input: {
+    noteableId: "gid://gitlab/Issue/123456",
+    body: "Este issue ha sido resuelto en el commit abc123"
+  }) {
+    note {
+      id
+      body
+      createdAt
+    }
+    errors
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar issues
+glab issue list
+
+# Listar issues abiertas con filtro
+glab issue list --state opened --label bug
+
+# Ver issue específica
+glab issue view 42
+
+# Ver issue en browser
+glab issue view 42 --web
+
+# Crear issue
+glab issue create --title "Bug en login" \
+  --description "El login no funciona" \
+  --label bug,high-priority
+
+# Cerrar issue
+glab issue close 42
+
+# Reabrir issue
+glab issue reopen 42
+
+# Agregar comentario
+glab issue note 42 --message "Resuelto en commit abc123"
+```
+
+---
+
+### 4. Merge Requests
+
+#### REST API
+
+**Listar merge requests:**
+```bash
+# Todos los MRs del proyecto
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests"
+
+# MRs abiertos
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests?state=opened"
+
+# MRs con filtros
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests?state=opened&labels=feature&author_id=5"
+```
+
+**Obtener MR específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10"
+```
+
+**Crear merge request:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "source_branch": "feature-branch",
+    "target_branch": "main",
+    "title": "Add new feature",
+    "description": "This MR adds a new feature",
+    "assignee_id": 5,
+    "labels": "feature,ready-for-review"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests"
+```
+
+**Actualizar merge request:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "title": "Updated title",
+    "labels": "feature,reviewed"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10"
+```
+
+**Aprobar merge request:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/approve"
+```
+
+**Merge merge request:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "merge_commit_message": "Merge feature branch",
+    "squash": true,
+    "should_remove_source_branch": true
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/merge"
+```
+
+**Obtener cambios del MR:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/changes"
+```
+
+**Obtener commits del MR:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/commits"
+```
+
+#### GraphQL API
+
+**Query merge requests:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    mergeRequests(
+      state: OPENED
+      first: 20
+    ) {
+      nodes {
+        iid
+        title
+        description
+        state
+        sourceBranch
+        targetBranch
+        author {
+          username
+        }
+        assignees {
+          nodes {
+            username
+          }
+        }
+        labels {
+          nodes {
+            title
+          }
+        }
+        createdAt
+        updatedAt
+        webUrl
+      }
+    }
+  }
+}
+```
+
+**Mutation: Crear merge request:**
+```graphql
+mutation {
+  mergeRequestCreate(input: {
+    projectPath: "grupo/proyecto",
+    sourceBranch: "feature-branch",
+    targetBranch: "main",
+    title: "Add new feature",
+    description: "This MR adds a new feature"
+  }) {
+    mergeRequest {
+      iid
+      title
+      webUrl
+    }
+    errors
+  }
+}
+```
+
+**Mutation: Actualizar merge request:**
+```graphql
+mutation {
+  mergeRequestUpdate(input: {
+    projectPath: "grupo/proyecto",
+    iid: "10",
+    title: "Updated title"
+  }) {
+    mergeRequest {
+      iid
+      title
+    }
+    errors
+  }
+}
+```
+
+**Mutation: Merge merge request:**
+```graphql
+mutation {
+  mergeRequestMerge(input: {
+    projectPath: "grupo/proyecto",
+    iid: "10",
+    squash: true,
+    shouldRemoveSourceBranch: true
+  }) {
+    mergeRequest {
+      iid
+      state
+    }
+    errors
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar merge requests
+glab mr list
+
+# Listar MRs abiertos con filtro
+glab mr list --state opened --label feature
+
+# Ver merge request
+glab mr view 10
+
+# Ver MR en browser
+glab mr view 10 --web
+
+# Crear merge request
+glab mr create --source-branch feature-branch \
+  --target-branch main \
+  --title "Add new feature" \
+  --description "This MR adds a new feature" \
+  --label feature
+
+# Crear MR con template
+glab mr create --fill
+
+# Checkout merge request localmente
+glab mr checkout 10
+
+# Aprobar merge request
+glab mr approve 10
+
+# Merge merge request
+glab mr merge 10
+
+# Ver diff del MR
+glab mr diff 10
+
+# Ver issues relacionados
+glab mr issues 10
+
+# Agregar comentario
+glab mr note 10 --message "LGTM!"
+```
+
+---
+
+### 5. Pipelines
+
+#### REST API
+
+**Listar pipelines:**
+```bash
+# Todos los pipelines
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines"
+
+# Pipelines con filtros
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines?status=running&ref=main"
+
+# Pipelines por fecha
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines?updated_after=2026-01-01T00:00:00Z"
+```
+
+**Obtener pipeline específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456"
+```
+
+**Obtener último pipeline:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/latest?ref=main"
+```
+
+**Crear pipeline:**
+```bash
+# Pipeline simple
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipeline?ref=main"
+
+# Pipeline con variables
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "ref": "main",
+    "variables": [
+      {"key": "DEPLOY_ENV", "value": "production"},
+      {"key": "DEBUG", "value": "true"}
+    ]
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipeline"
+
+# Pipeline con inputs
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "ref": "main",
+    "inputs": {
+      "environment": "production",
+      "scan_security": true,
+      "level": 3
+    }
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipeline"
+```
+
+**Reintentar pipeline:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456/retry"
+```
+
+**Cancelar pipeline:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456/cancel"
+```
+
+**Eliminar pipeline:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456"
+```
+
+**Obtener variables del pipeline:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456/variables"
+```
+
+**Obtener test report:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456/test_report"
+```
+
+#### GraphQL API
+
+**Query pipelines:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    pipelines(first: 20, status: RUNNING) {
+      nodes {
+        id
+        iid
+        status
+        ref
+        sha
+        createdAt
+        updatedAt
+        duration
+        coverage
+        user {
+          username
+        }
+        jobs {
+          nodes {
+            name
+            status
+            stage
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Mutation: Crear pipeline:**
+```graphql
+mutation {
+  pipelineCreate(input: {
+    projectPath: "grupo/proyecto",
+    ref: "main"
+  }) {
+    pipeline {
+      id
+      iid
+      status
+    }
+    errors
+  }
+}
+```
+
+**Mutation: Cancelar pipeline:**
+```graphql
+mutation {
+  pipelineCancel(input: {
+    id: "gid://gitlab/Ci::Pipeline/456"
+  }) {
+    pipeline {
+      id
+      status
+    }
+    errors
+  }
+}
+```
+
+**Mutation: Reintentar pipeline:**
+```graphql
+mutation {
+  pipelineRetry(input: {
+    id: "gid://gitlab/Ci::Pipeline/456"
+  }) {
+    pipeline {
+      id
+      status
+    }
+    errors
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar pipelines
+glab ci list
+glab pipeline list
+
+# Ver pipeline específico
+glab ci view 456
+glab pipeline view 456
+
+# Ver status del pipeline actual
+glab ci status
+
+# Ver trace de pipeline
+glab ci trace
+
+# Reintentar pipeline
+glab pipeline retry 456
+
+# Cancelar pipeline
+glab pipeline cancel 456
+
+# Eliminar pipeline
+glab pipeline delete 456
+
+# Ejecutar pipeline manualmente
+glab pipeline run
+glab pipeline run --branch main --variables "DEPLOY_ENV=production,DEBUG=true"
+```
+
+---
+
+### 6. Jobs
+
+#### REST API
+
+**Listar jobs de un proyecto:**
+```bash
+# Todos los jobs
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs"
+
+# Jobs de un pipeline específico
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/pipelines/456/jobs"
+
+# Jobs con filtros
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs?scope[]=failed&scope[]=running"
+```
+
+**Obtener job específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789"
+```
+
+**Obtener trace/log de un job:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789/trace"
+```
+
+**Reintentar job:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789/retry"
+```
+
+**Cancelar job:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789/cancel"
+```
+
+**Ejecutar job manual:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789/play"
+```
+
+**Descargar artifacts:**
+```bash
+# Artifacts de un job específico
+curl --header "PRIVATE-TOKEN: <token>" \
+  --output artifacts.zip \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789/artifacts"
+
+# Artifacts por job name y ref
+curl --header "PRIVATE-TOKEN: <token>" \
+  --output artifacts.zip \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/artifacts/main/download?job=build"
+```
+
+**Obtener archivo específico de artifacts:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/jobs/789/artifacts/path/to/file.txt"
+```
+
+#### GraphQL API
+
+**Query jobs:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    pipeline(iid: "456") {
+      jobs {
+        nodes {
+          id
+          name
+          status
+          stage
+          duration
+          createdAt
+          finishedAt
+          webPath
+        }
+      }
+    }
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar jobs del pipeline actual
+glab ci view
+
+# Ver trace de un job
+glab ci trace
+glab ci trace <job-id>
+
+# Ver trace de job específico por nombre
+glab ci trace --job build
+
+# Reintentar job
+glab job retry <job-id>
+
+# Cancelar job
+glab job cancel <job-id>
+
+# Ejecutar job manual
+glab job play <job-id>
+
+# Descargar artifacts
+glab job artifacts <job-id>
+```
+
+---
+
+### 7. Repository & Files
+
+#### REST API - Repository
+
+**Obtener información del repositorio:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository"
+```
+
+**Listar branches:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/branches"
+```
+
+**Crear branch:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "branch": "new-feature",
+    "ref": "main"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/branches"
+```
+
+**Eliminar branch:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/branches/feature-branch"
+```
+
+**Listar tags:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/tags"
+```
+
+**Crear tag:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "tag_name": "v1.0.0",
+    "ref": "main",
+    "message": "Release version 1.0.0"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/tags"
+```
+
+**Listar commits:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits"
+
+# Con filtros
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits?ref_name=main&since=2026-01-01T00:00:00Z"
+```
+
+**Obtener commit específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits/abc123"
+```
+
+**Listar árbol de archivos:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/tree"
+
+# Subdirectorio específico
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/tree?path=src/components"
+```
+
+#### REST API - Files
+
+**Obtener archivo:**
+```bash
+# Información completa (Base64 encoded)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fapp.js?ref=main"
+
+# Contenido raw
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fapp.js/raw?ref=main"
+
+# Usar HEAD para default branch
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/README.md?ref=HEAD"
+```
+
+**Crear archivo:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "branch": "main",
+    "commit_message": "Add new file",
+    "content": "console.log(\"Hello World\");",
+    "author_name": "John Doe",
+    "author_email": "john@example.com"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fnew-file.js"
+```
+
+**Actualizar archivo:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "branch": "main",
+    "commit_message": "Update file",
+    "content": "console.log(\"Updated content\");"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fapp.js"
+```
+
+**Eliminar archivo:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "branch": "main",
+    "commit_message": "Delete file"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fold-file.js"
+```
+
+**Obtener blame de archivo:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fapp.js/blame?ref=main"
+
+# Rango específico
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/src%2Fapp.js/blame?ref=main&range[start]=1&range[end]=50"
+```
+
+#### GraphQL API
+
+**Query repository:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    repository {
+      rootRef
+      tree {
+        trees {
+          nodes {
+            name
+            type
+            path
+          }
+        }
+        blobs {
+          nodes {
+            name
+            path
+            size
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Query archivo específico:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    repository {
+      blobs(paths: ["README.md", "src/app.js"]) {
+        nodes {
+          path
+          name
+          size
+          rawBlob
+        }
+      }
+    }
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Ver repositorio
+glab repo view
+
+# Clonar repositorio
+glab repo clone grupo/proyecto
+
+# Ver archivo
+glab repo view --file src/app.js
+
+# Ver commits
+glab repo view --commits
+
+# Ver branches
+glab repo view --branches
+```
+
+---
+
+### 8. Releases
+
+#### REST API
+
+**Listar releases:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/releases"
+```
+
+**Obtener release específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/releases/v1.0.0"
+```
+
+**Crear release:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "tag_name": "v1.0.0",
+    "name": "Release 1.0.0",
+    "description": "## Features\n- New feature 1\n- New feature 2\n\n## Bug Fixes\n- Fixed bug 1",
+    "ref": "main",
+    "assets": {
+      "links": [
+        {
+          "name": "Documentation",
+          "url": "https://docs.example.com"
+        }
+      ]
+    }
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/releases"
+```
+
+**Actualizar release:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name": "Release 1.0.0 - Updated",
+    "description": "Updated description"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/releases/v1.0.0"
+```
+
+**Eliminar release:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/releases/v1.0.0"
+```
+
+#### GraphQL API
+
+**Query releases:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    releases(first: 10) {
+      nodes {
+        tagName
+        name
+        description
+        createdAt
+        releasedAt
+        assets {
+          links {
+            nodes {
+              name
+              url
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+**Mutation: Crear release:**
+```graphql
+mutation {
+  releaseCreate(input: {
+    projectPath: "grupo/proyecto",
+    tagName: "v1.0.0",
+    name: "Release 1.0.0",
+    description: "Release notes",
+    ref: "main"
+  }) {
+    release {
+      tagName
+      name
+    }
+    errors
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Listar releases
+glab release list
+
+# Ver release específico
+glab release view v1.0.0
+
+# Crear release
+glab release create v1.0.0 \
+  --name "Release 1.0.0" \
+  --notes "Release notes"
+
+# Crear release con assets
+glab release create v1.0.0 \
+  --name "Release 1.0.0" \
+  --notes "Release notes" \
+  --asset-link '{"name":"Documentation","url":"https://docs.example.com"}'
+
+# Eliminar release
+glab release delete v1.0.0
+```
+
+---
+
+### 9. Webhooks (Project Hooks)
+
+#### REST API
+
+**Listar hooks:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/hooks"
+```
+
+**Obtener hook específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/hooks/456"
+```
+
+**Crear hook:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "url": "https://example.com/webhook",
+    "push_events": true,
+    "merge_requests_events": true,
+    "issues_events": true,
+    "pipeline_events": true,
+    "job_events": true,
+    "token": "secret-token",
+    "enable_ssl_verification": true
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/hooks"
+```
+
+**Actualizar hook:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "url": "https://example.com/webhook-updated",
+    "push_events": false
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/hooks/456"
+```
+
+**Eliminar hook:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/hooks/456"
+```
+
+**Testear hook:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/hooks/456/test/push_events"
+```
+
+#### glab CLI
+
+```bash
+# Listar hooks
+glab api projects/123/hooks
+
+# Crear hook
+glab api --method POST projects/123/hooks \
+  --field url=https://example.com/webhook \
+  --field push_events=true \
+  --field merge_requests_events=true
+
+# Eliminar hook
+glab api --method DELETE projects/123/hooks/456
+```
+
+---
+
+### 10. Variables CI/CD
+
+#### REST API
+
+**Listar variables:**
+```bash
+# Variables de proyecto
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/variables"
+
+# Variables de grupo
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/groups/456/variables"
+```
+
+**Obtener variable específica:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/variables/DEPLOY_KEY"
+```
+
+**Crear variable:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "key": "DEPLOY_KEY",
+    "value": "secret-value",
+    "protected": true,
+    "masked": true,
+    "environment_scope": "production"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/variables"
+```
+
+**Actualizar variable:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "value": "new-secret-value",
+    "protected": false
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/variables/DEPLOY_KEY"
+```
+
+**Eliminar variable:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/variables/DEPLOY_KEY"
+```
+
+#### glab CLI
+
+```bash
+# Listar variables
+glab variable list
+
+# Obtener variable específica
+glab variable get DEPLOY_KEY
+
+# Crear variable
+glab variable set DEPLOY_KEY "secret-value" \
+  --scope production \
+  --protected \
+  --masked
+
+# Actualizar variable
+glab variable update DEPLOY_KEY "new-value"
+
+# Eliminar variable
+glab variable delete DEPLOY_KEY
+```
+
+---
+
+### 11. GraphQL - Queries Avanzadas
+
+#### Query con múltiples recursos:
+```graphql
+query {
+  currentUser {
+    id
+    username
+    name
+  }
+  project(fullPath: "grupo/proyecto") {
+    id
+    name
+    issues(first: 5, state: OPENED) {
+      nodes {
+        iid
+        title
+      }
+    }
+    mergeRequests(first: 5, state: OPENED) {
+      nodes {
+        iid
+        title
+      }
+    }
+  }
+}
+```
+
+#### Query con paginación completa:
+```graphql
+query($cursor: String) {
+  project(fullPath: "grupo/proyecto") {
+    issues(
+      first: 20
+      after: $cursor
+      state: OPENED
+      sort: CREATED_DESC
+    ) {
+      edges {
+        node {
+          iid
+          title
+          description
+          labels {
+            nodes {
+              title
+              color
+            }
+          }
+          assignees {
+            nodes {
+              username
+              name
+            }
+          }
+          author {
+            username
+          }
+          createdAt
+          updatedAt
+        }
+        cursor
+      }
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+    }
+  }
+}
+```
+
+Variables:
+```json
+{
+  "cursor": null
+}
+```
+
+#### Query con complejidad:
+```graphql
+query {
+  queryComplexity {
+    score
+    limit
+  }
+  project(fullPath: "grupo/proyecto") {
+    name
+    issues(first: 10) {
+      nodes {
+        title
+      }
+    }
+  }
+}
+```
+
+#### Multiplex queries (batch):
+```bash
+curl --request POST \
+  --header "Authorization: Bearer $TOKEN" \
+  --header "Content-Type: application/json" \
+  --data '[
+    {"query": "query {project(fullPath: \"grupo/proyecto1\") {id name}}"},
+    {"query": "query {project(fullPath: \"grupo/proyecto2\") {id name}}"},
+    {"query": "query {currentUser {username}}"}
+  ]' \
+  --url "https://gitlab.com/api/graphql"
+```
+
+---
+
+### 12. GraphQL - Mutations Avanzadas
+
+#### Mutation con múltiples operaciones:
+```graphql
+mutation {
+  createIssue: createIssue(input: {
+    projectPath: "grupo/proyecto",
+    title: "New issue"
+  }) {
+    issue {
+      iid
+    }
+    errors
+  }
+  
+  updateProject: updateProject(input: {
+    projectPath: "grupo/proyecto",
+    description: "Updated description"
+  }) {
+    project {
+      description
+    }
+    errors
+  }
+}
+```
+
+#### Mutation con variables:
+```graphql
+mutation CreateIssueWithLabels(
+  $projectPath: ID!,
+  $title: String!,
+  $description: String,
+  $labelIds: [LabelID!]
+) {
+  createIssue(input: {
+    projectPath: $projectPath,
+    title: $title,
+    description: $description,
+    labelIds: $labelIds
+  }) {
+    issue {
+      iid
+      title
+      labels {
+        nodes {
+          title
+        }
+      }
+    }
+    errors
+  }
+}
+```
+
+Variables:
+```json
+{
+  "projectPath": "grupo/proyecto",
+  "title": "Bug en login",
+  "description": "Descripción detallada",
+  "labelIds": [
+    "gid://gitlab/Label/1",
+    "gid://gitlab/Label/2"
+  ]
+}
+```
+
+---
+
+### 13. glab API - Llamadas Directas
+
+```bash
+# GET request
+glab api projects/123
+
+# GET con parámetros
+glab api "projects/123/issues?state=opened&labels=bug"
+
+# POST request
+glab api --method POST projects/123/issues \
+  --field title="New issue" \
+  --field description="Description"
+
+# PUT request
+glab api --method PUT projects/123/issues/42 \
+  --field state_event=close
+
+# DELETE request
+glab api --method DELETE projects/123/issues/42
+
+# Con paginación
+glab api --paginate projects/123/issues
+
+# Output en formato específico
+glab api projects/123 --jq '.name'
+
+# Headers personalizados
+glab api --header "Custom-Header: value" projects/123
+
+# Raw output
+glab api --raw projects/123
+```
+
+---
+
+### 14. Búsqueda y Filtrado
+
+#### REST API
+
+**Buscar proyectos:**
+```bash
+# Por nombre
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects?search=my-project"
+
+# Por visibilidad
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects?visibility=public"
+
+# Proyectos propios
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects?owned=true"
+```
+
+**Buscar issues:**
+```bash
+# Por título
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues?search=login"
+
+# Por labels
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues?labels=bug,critical"
+
+# Por assignee
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues?assignee_id=5"
+
+# Por milestone
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues?milestone=v1.0"
+```
+
+**Buscar merge requests:**
+```bash
+# Por autor
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests?author_id=5"
+
+# Por reviewer
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests?reviewer_id=10"
+
+# Por source branch
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests?source_branch=feature-branch"
+```
+
+#### GraphQL API
+
+**Buscar con filtros:**
+```graphql
+query {
+  projects(
+    search: "my-project"
+    membership: true
+    first: 20
+  ) {
+    nodes {
+      id
+      name
+      fullPath
+    }
+  }
+}
+```
+
+**Buscar issues con filtros complejos:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    issues(
+      search: "login"
+      labelName: ["bug", "critical"]
+      assigneeUsernames: ["user1", "user2"]
+      state: OPENED
+      sort: CREATED_DESC
+      first: 20
+    ) {
+      nodes {
+        iid
+        title
+        state
+      }
+    }
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Buscar issues
+glab issue list --search "login" --label bug
+
+# Buscar merge requests
+glab mr list --search "feature" --author @me
+
+# Buscar proyectos
+glab repo list --search "my-project"
+```
+
+---
+
+### 15. Users y Autenticación
+
+#### REST API
+
+**Obtener usuario actual:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/user"
+```
+
+**Listar usuarios:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/users"
+
+# Con búsqueda
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/users?search=john"
+```
+
+**Obtener usuario específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/users/123"
+```
+
+#### GraphQL API
+
+**Query usuario actual:**
+```graphql
+query {
+  currentUser {
+    id
+    username
+    name
+    email
+    publicEmail
+    avatarUrl
+    webUrl
+    status {
+      message
+      emoji
+    }
+  }
+}
+```
+
+**Query usuarios:**
+```graphql
+query {
+  users(search: "john", first: 20) {
+    nodes {
+      id
+      username
+      name
+      publicEmail
+    }
+  }
+}
+```
+
+#### glab CLI
+
+```bash
+# Ver usuario actual
+glab user view
+
+# Ver usuario específico
+glab user view username
+
+# Listar usuarios
+glab api users
+```
+
+---
+
+### 16. Labels
+
+#### REST API
+
+**Listar labels:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/labels"
+```
+
+**Crear label:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name": "bug",
+    "color": "#FF0000",
+    "description": "Bug tracking label"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/labels"
+```
+
+**Actualizar label:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "new_name": "critical-bug",
+    "color": "#CC0000"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/labels/bug"
+```
+
+**Eliminar label:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/labels/bug"
+```
+
+#### glab CLI
+
+```bash
+# Listar labels
+glab label list
+
+# Crear label
+glab label create bug --color "#FF0000" --description "Bug tracking"
+
+# Eliminar label
+glab label delete bug
+```
+
+---
+
+### 17. Milestones
+
+#### REST API
+
+**Listar milestones:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/milestones"
+```
+
+**Crear milestone:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "title": "v1.0",
+    "description": "Release 1.0",
+    "due_date": "2026-12-31",
+    "start_date": "2026-01-01"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/milestones"
+```
+
+**Actualizar milestone:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "state_event": "close"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/milestones/1"
+```
+
+#### glab CLI
+
+```bash
+# Listar milestones
+glab milestone list
+
+# Ver milestone
+glab milestone view 1
+
+# Crear milestone
+glab milestone create --title "v1.0" --due-date "2026-12-31"
+
+# Cerrar milestone
+glab milestone close 1
+```
+
+---
+
+### 18. Snippets
+
+#### REST API
+
+**Listar snippets:**
+```bash
+# Snippets del usuario
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/snippets"
+
+# Snippets del proyecto
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/snippets"
+```
+
+**Crear snippet:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "title": "Example snippet",
+    "file_name": "example.rb",
+    "content": "puts \"Hello World\"",
+    "visibility": "private"
+  }' \
+  --url "https://gitlab.example.com/api/v4/snippets"
+```
+
+**Obtener snippet:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/snippets/456"
+
+# Raw content
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/snippets/456/raw"
+```
+
+#### glab CLI
+
+```bash
+# Listar snippets
+glab snippet list
+
+# Ver snippet
+glab snippet view 456
+
+# Crear snippet
+glab snippet create --title "Example" \
+  --filename "example.rb" \
+  --content "puts 'Hello'"
+```
+
+---
+
+### 19. Runners
+
+#### REST API
+
+**Listar runners:**
+```bash
+# Runners del proyecto
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/runners"
+
+# Todos los runners (admin)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/runners/all"
+```
+
+**Obtener runner específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/runners/456"
+```
+
+**Actualizar runner:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "description": "Updated runner",
+    "active": true,
+    "tag_list": ["docker", "linux"]
+  }' \
+  --url "https://gitlab.example.com/api/v4/runners/456"
+```
+
+**Eliminar runner:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/runners/456"
+```
+
+#### GraphQL API
+
+**Query runners:**
+```graphql
+query {
+  runner(id: "gid://gitlab/Ci::Runner/456") {
+    id
+    description
+    active
+    paused
+    tagList
+    runnerType
+  }
+}
+```
+
+---
+
+### 20. Container Registry
+
+#### REST API
+
+**Listar repositorios del registry:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/registry/repositories"
+```
+
+**Listar tags de un repositorio:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/registry/repositories/456/tags"
+```
+
+**Obtener detalles de un tag:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/registry/repositories/456/tags/latest"
+```
+
+**Eliminar tag:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/registry/repositories/456/tags/old-tag"
+```
+
+**Eliminar tags en bulk:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name_regex_delete": ".*-dev",
+    "keep_n": 5,
+    "older_than": "1d"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/registry/repositories/456/tags"
+```
+
+---
+
+### 21. Deployments
+
+#### REST API
+
+**Listar deployments:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/deployments"
+
+# Con filtros
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/deployments?environment=production&status=success"
+```
+
+**Obtener deployment específico:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/deployments/456"
+```
+
+**Crear deployment:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "environment": "production",
+    "sha": "abc123",
+    "ref": "main",
+    "tag": false,
+    "status": "success"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/deployments"
+```
+
+#### GraphQL API
+
+**Query deployments:**
+```graphql
+query {
+  project(fullPath: "grupo/proyecto") {
+    deployments(first: 10) {
+      nodes {
+        id
+        iid
+        ref
+        sha
+        createdAt
+        finishedAt
+        status
+        environment {
+          name
+        }
+      }
+    }
+  }
+}
+```
+
+---
+
+### 22. Environments
+
+#### REST API
+
+**Listar environments:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/environments"
+```
+
+**Crear environment:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name": "staging",
+    "external_url": "https://staging.example.com"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/environments"
+```
+
+**Actualizar environment:**
+```bash
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "external_url": "https://new-staging.example.com"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/environments/456"
+```
+
+**Stop environment:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/environments/456/stop"
+```
+
+---
+
+### 23. Protected Branches
+
+#### REST API
+
+**Listar protected branches:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/protected_branches"
+```
+
+**Proteger branch:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "name": "main",
+    "push_access_level": 40,
+    "merge_access_level": 30,
+    "allow_force_push": false
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/protected_branches"
+```
+
+**Desproteger branch:**
+```bash
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/protected_branches/main"
+```
+
+---
+
+### 24. Commits
+
+#### REST API
+
+**Crear commit con múltiples archivos:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "branch": "main",
+    "commit_message": "Update multiple files",
+    "actions": [
+      {
+        "action": "create",
+        "file_path": "new-file.txt",
+        "content": "New file content"
+      },
+      {
+        "action": "update",
+        "file_path": "existing-file.txt",
+        "content": "Updated content"
+      },
+      {
+        "action": "delete",
+        "file_path": "old-file.txt"
+      },
+      {
+        "action": "move",
+        "file_path": "renamed-file.txt",
+        "previous_path": "old-name.txt"
+      }
+    ]
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits"
+```
+
+**Obtener diff de commit:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits/abc123/diff"
+```
+
+**Obtener comentarios de commit:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits/abc123/comments"
+```
+
+**Agregar comentario a commit:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "note": "This commit looks good",
+    "path": "src/app.js",
+    "line": 10,
+    "line_type": "new"
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/commits/abc123/comments"
+```
+
+---
+
+### 25. Merge Request Approvals
+
+#### REST API
+
+**Obtener configuración de approvals:**
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/approvals"
+```
+
+**Configurar approvals requeridos:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{
+    "approvals_required": 2
+  }' \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/approvals"
+```
+
+**Aprobar MR:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/approve"
+```
+
+**Remover aprobación:**
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/merge_requests/10/unapprove"
+```
+
+---
+
+## Troubleshooting y Códigos HTTP
+
+### Códigos de Estado Comunes
+
+#### 2xx - Éxito
+
+**200 OK**
+- **Significado**: Request exitoso (GET/PUT/PATCH/DELETE)
+- **Acción**: Procesar respuesta JSON
+- **Ejemplo**:
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 200 OK con datos del proyecto
+```
+
+**201 Created**
+- **Significado**: Recurso creado exitosamente (POST)
+- **Acción**: Recurso nuevo disponible en respuesta
+- **Ejemplo**:
+```bash
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{"title": "New issue"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues"
+# Response: 201 Created con datos de la issue creada
+```
+
+**202 Accepted**
+- **Significado**: Request aceptado, procesamiento asíncrono
+- **Acción**: Verificar estado posteriormente
+- **Ejemplo**: Operaciones de importación, exports
+
+**204 No Content**
+- **Significado**: Éxito sin contenido en respuesta
+- **Acción**: Operación completada, no hay datos adicionales
+- **Ejemplo**: DELETE exitoso
+
+---
+
+#### 3xx - Redirección
+
+**301 Moved Permanently**
+- **Significado**: Recurso movido permanentemente
+- **Acción**: Usar URL del header `Location`
+- **Ejemplo**: Proyecto renombrado o movido
+```bash
+# Request a path antiguo
+curl --verbose --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/old-group%2Fold-project"
+# Response: 301 con Location: /api/v4/projects/new-group%2Fnew-project
+```
+
+**304 Not Modified**
+- **Significado**: Recurso no modificado desde última request
+- **Acción**: Usar caché local
+- **Ejemplo**: Request condicional con `If-Modified-Since`
+
+---
+
+#### 4xx - Errores del Cliente
+
+**400 Bad Request**
+- **Significado**: Parámetro requerido faltante o inválido
+- **Acción**: Verificar parámetros y formato
+- **Ejemplos**:
+
+```bash
+# Error: Atributo faltante
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{"description": "Missing title"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues"
+# Response: 400 {"message":"400 (Bad request) \"title\" not given"}
+```
+
+```bash
+# Error: Validación fallida
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "Content-Type: application/json" \
+  --data '{"title": "A", "description": "Too short title"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues"
+# Response: 400 {"message":{"title":["is too short (minimum is 3 characters)"]}}
+```
+
+**Resolución**:
+1. Verificar documentación del endpoint
+2. Validar todos los campos requeridos
+3. Verificar formato de datos (JSON válido)
+4. Revisar tipos de datos (string, integer, boolean)
+
+---
+
+**401 Unauthorized**
+- **Significado**: No autenticado o token inválido
+- **Acción**: Verificar token de autenticación
+- **Ejemplos**:
+
+```bash
+# Error: Token faltante
+curl --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 401 {"message":"401 Unauthorized"}
+
+# Error: Token inválido
+curl --header "PRIVATE-TOKEN: invalid-token" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 401 {"message":"Invalid token"}
+```
+
+**Resolución**:
+1. Verificar que el token existe y es válido
+2. Verificar que el token no ha expirado
+3. Verificar que el header está correctamente formateado
+4. Para GraphQL: verificar scope del token (`api` o `read_api`)
+
+```bash
+# Verificar token
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/user"
+# Si retorna datos del usuario, el token es válido
+```
+
+---
+
+**403 Forbidden**
+- **Significado**: Autenticado pero sin permisos
+- **Acción**: Verificar permisos del usuario/token
+- **Ejemplos**:
+
+```bash
+# Error: Sin permisos para eliminar proyecto
+curl --request DELETE \
+  --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 403 {"message":"403 Forbidden"}
+
+# Error: Scope insuficiente
+curl --request POST \
+  --header "PRIVATE-TOKEN: <read-only-token>" \
+  --data '{"title": "New issue"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues"
+# Response: 403 {"error":"insufficient_scope"}
+```
+
+**Resolución**:
+1. Verificar rol del usuario (Guest, Reporter, Developer, Maintainer, Owner)
+2. Verificar scope del token (`api` para write, `read_api` para read-only)
+3. Verificar permisos del proyecto/grupo
+4. Para operaciones de admin: verificar que el usuario es administrador
+
+---
+
+**404 Not Found**
+- **Significado**: Recurso no encontrado o sin acceso
+- **Acción**: Verificar ID/path y permisos
+- **Ejemplos**:
+
+```bash
+# Error: Proyecto no existe
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/999999"
+# Response: 404 {"message":"404 Project Not Found"}
+
+# Error: Path incorrecto (falta URL encoding)
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/grupo/proyecto"
+# Response: 404 (debe ser grupo%2Fproyecto)
+
+# Error: Issue no existe
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123/issues/999999"
+# Response: 404 {"message":"404 Not found"}
+```
+
+**Resolución**:
+1. Verificar que el ID/path es correcto
+2. URL-encode paths con `/` → `%2F`
+3. Verificar que el recurso existe
+4. Verificar permisos de acceso al recurso
+5. Para proyectos: usar ID numérico en lugar de path si hay problemas
+
+```bash
+# Obtener ID de proyecto por path
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/grupo%2Fproyecto" | jq '.id'
+```
+
+---
+
+**409 Conflict**
+- **Significado**: Recurso conflictivo ya existe
+- **Acción**: Resolver conflicto (renombrar, actualizar en lugar de crear)
+- **Ejemplos**:
+
+```bash
+# Error: Branch ya existe
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --data '{"branch": "main", "ref": "main"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/branches"
+# Response: 409 {"message":"Branch already exists"}
+
+# Error: Label duplicado
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --data '{"name": "bug", "color": "#FF0000"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/labels"
+# Response: 409 {"message":"Label already exists"}
+```
+
+**Resolución**:
+1. Verificar si el recurso ya existe antes de crear
+2. Usar PUT/PATCH para actualizar en lugar de POST para crear
+3. Usar nombres únicos para recursos nuevos
+
+---
+
+**412 Precondition Failed**
+- **Significado**: Precondición del request falló
+- **Acción**: Verificar headers condicionales
+- **Ejemplo**:
+
+```bash
+# Error: Archivo modificado entre lectura y escritura
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --header "If-Unmodified-Since: Wed, 01 Jan 2026 00:00:00 GMT" \
+  --data '{"content": "new content"}' \
+  --url "https://gitlab.example.com/api/v4/projects/123/repository/files/file.txt"
+# Response: 412 (archivo modificado después de la fecha)
+```
+
+**Resolución**:
+1. Refrescar datos antes de actualizar
+2. Usar `last_commit_id` para verificar versión
+3. Implementar retry con datos actualizados
+
+---
+
+**422 Unprocessable Entity**
+- **Significado**: Entidad no procesable (validación falló)
+- **Acción**: Verificar validación de campos
+- **Ejemplos**:
+
+```bash
+# Error: Email inválido
+curl --request POST \
+  --header "PRIVATE-TOKEN: <token>" \
+  --data '{"email": "invalid-email", "name": "User"}' \
+  --url "https://gitlab.example.com/api/v4/users"
+# Response: 422 {"message":{"email":["is invalid"]}}
+
+# Error: Valor fuera de rango
+curl --request PUT \
+  --header "PRIVATE-TOKEN: <token>" \
+  --data '{"per_page": 150}' \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 422 {"message":{"per_page":["must be less than or equal to 100"]}}
+```
+
+**Resolución**:
+1. Leer mensaje de error detallado
+2. Verificar formato de campos (email, URL, etc.)
+3. Verificar rangos de valores numéricos
+4. Verificar longitud de strings
+5. Verificar valores enum válidos
+
+---
+
+**429 Too Many Requests**
+- **Significado**: Rate limit excedido
+- **Acción**: Esperar y reintentar con backoff exponencial
+- **Ejemplo**:
+
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 429 {"message":"429 Too Many Requests"}
+```
+
+**Resolución con retry automático**:
+
+```bash
+#!/bin/bash
+
+retry_with_backoff() {
+  local url="$1"
+  local max_attempts=5
+  local timeout=1
+  local attempt=1
+  
+  while [ $attempt -le $max_attempts ]; do
+    echo "Attempt $attempt of $max_attempts..."
+    
+    HTTP_CODE=$(curl --write-out '%{http_code}' \
+      --silent \
+      --output response.json \
+      --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+      "$url")
+    
+    if [ "$HTTP_CODE" -eq 429 ]; then
+      echo "Rate limited. Waiting ${timeout}s before retry..."
+      sleep $timeout
+      timeout=$((timeout * 2))  # Backoff exponencial
+      attempt=$((attempt + 1))
+    elif [ "$HTTP_CODE" -ge 200 ] && [ "$HTTP_CODE" -lt 300 ]; then
+      echo "Success!"
+      cat response.json
+      return 0
+    else
+      echo "Error: HTTP $HTTP_CODE"
+      cat response.json
+      return 1
+    fi
+  done
+  
+  echo "Max retries exceeded"
+  return 1
+}
+
+# Uso
+retry_with_backoff "https://gitlab.example.com/api/v4/projects/123"
+```
+
+**Mejores prácticas**:
+1. Implementar backoff exponencial (1s, 2s, 4s, 8s, 16s)
+2. Verificar headers `RateLimit-*` en respuestas
+3. Usar keyset pagination en lugar de offset para grandes datasets
+4. Batch operations cuando sea posible (GraphQL multiplex)
+5. Cachear respuestas cuando sea apropiado
+
+---
+
+#### 5xx - Errores del Servidor
+
+**500 Internal Server Error**
+- **Significado**: Error interno del servidor
+- **Acción**: Reportar a administrador, reintentar más tarde
+- **Ejemplo**:
+
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 500 {"message":"500 Internal Server Error"}
+```
+
+**Resolución**:
+1. Verificar logs del servidor (si tienes acceso)
+2. Reintentar después de unos minutos
+3. Reportar a administrador con detalles del request
+4. Verificar status de GitLab.com (si aplica)
+
+---
+
+**503 Service Unavailable**
+- **Significado**: Servidor temporalmente sobrecargado
+- **Acción**: Reintentar con backoff
+- **Ejemplo**:
+
+```bash
+curl --header "PRIVATE-TOKEN: <token>" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+# Response: 503 {"message":"503 Service Unavailable"}
+```
+
+**Resolución**:
+1. Esperar y reintentar (similar a 429)
+2. Verificar header `Retry-After` si está presente
+3. Reducir frecuencia de requests
+4. Verificar status de GitLab.com
+
+---
+
+### Debugging Avanzado
+
+#### Capturar información completa del request:
+
+```bash
+#!/bin/bash
+
+debug_api_call() {
+  local method="${1:-GET}"
+  local url="$2"
+  local data="$3"
+  
+  echo "=== API Debug Info ==="
+  echo "Method: $method"
+  echo "URL: $url"
+  echo "Timestamp: $(date -Iseconds)"
+  echo ""
+  
+  if [ -n "$data" ]; then
+    curl --request "$method" \
+      --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+      --header "Content-Type: application/json" \
+      --data "$data" \
+      --verbose \
+      --include \
+      --output response_body.txt \
+      --write-out "\n=== Response Info ===\nHTTP Code: %{http_code}\nTotal Time: %{time_total}s\nSize: %{size_download} bytes\n" \
+      "$url" 2> request_debug.txt
+  else
+    curl --request "$method" \
+      --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+      --verbose \
+      --include \
+      --output response_body.txt \
+      --write-out "\n=== Response Info ===\nHTTP Code: %{http_code}\nTotal Time: %{time_total}s\nSize: %{size_download} bytes\n" \
+      "$url" 2> request_debug.txt
+  fi
+  
+  echo ""
+  echo "=== Request Debug ==="
+  cat request_debug.txt
+  echo ""
+  echo "=== Response Body ==="
+  cat response_body.txt | jq '.' 2>/dev/null || cat response_body.txt
+}
+
+# Uso
+debug_api_call GET "https://gitlab.example.com/api/v4/projects/123"
+debug_api_call POST "https://gitlab.example.com/api/v4/projects/123/issues" \
+  '{"title": "Test issue"}'
+```
+
+#### Verificar headers de respuesta:
+
+```bash
+# Capturar solo headers
+curl --head \
+  --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+
+# Headers importantes:
+# - RateLimit-Limit: Límite de requests
+# - RateLimit-Remaining: Requests restantes
+# - RateLimit-Reset: Timestamp de reset
+# - X-Total: Total de items (paginación)
+# - X-Total-Pages: Total de páginas
+# - X-Page: Página actual
+# - Link: Links de paginación
+```
+
+#### Verificar conectividad y DNS:
+
+```bash
+# Verificar resolución DNS
+nslookup gitlab.example.com
+
+# Verificar conectividad
+ping -c 4 gitlab.example.com
+
+# Verificar SSL/TLS
+openssl s_client -connect gitlab.example.com:443 -servername gitlab.example.com
+
+# Trace completo
+curl --trace-ascii trace.txt \
+  --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+  --url "https://gitlab.example.com/api/v4/projects/123"
+```
+
+---
+
+### Errores Específicos de GraphQL
+
+GraphQL siempre retorna HTTP 200, pero puede contener errores en la respuesta:
+
+#### Error de autenticación:
+```json
+{
+  "errors": [
+    {
+      "message": "Invalid token"
+    }
+  ]
+}
+```
+
+#### Error de query inválida:
+```json
+{
+  "errors": [
+    {
+      "message": "Field 'invalidField' doesn't exist on type 'Project'",
+      "locations": [{"line": 3, "column": 5}],
+      "path": ["project", "invalidField"]
+    }
+  ]
+}
+```
+
+#### Error de complejidad excedida:
+```json
+{
+  "errors": [
+    {
+      "message": "Query has complexity of 251, which exceeds max complexity of 250"
+    }
+  ]
+}
+```
+
+**Resolución**:
+1. Verificar sintaxis de query
+2. Verificar campos existen en schema
+3. Reducir complejidad (menos campos, menos niveles de anidamiento)
+4. Usar paginación para limitar resultados
+
+#### Verificar errores en GraphQL:
+
+```bash
+#!/bin/bash
+
+graphql_query() {
+  local query="$1"
+  
+  RESPONSE=$(curl --request POST \
+    --silent \
+    --header "Authorization: Bearer $GITLAB_TOKEN" \
+    --header "Content-Type: application/json" \
+    --data "{\"query\": \"$query\"}" \
+    --url "https://gitlab.com/api/graphql")
+  
+  # Verificar si hay errores
+  if echo "$RESPONSE" | jq -e '.errors' > /dev/null 2>&1; then
+    echo "❌ GraphQL Errors:"
+    echo "$RESPONSE" | jq '.errors'
+    return 1
+  else
+    echo "✅ Success:"
+    echo "$RESPONSE" | jq '.data'
+    return 0
+  fi
+}
+
+# Uso
+graphql_query 'query {currentUser {name}}'
+```
+
+---
+
+### Spam Detection
+
+#### REST API - Sin CAPTCHA:
+
+```json
+{
+  "message": {
+    "error": "Your snippet has been recognized as spam and has been discarded."
+  }
+}
+```
+
+**Resolución**: Modificar contenido para que no sea detectado como spam.
+
+#### REST API - Con CAPTCHA:
+
+```json
+{
+  "needs_captcha_response": true,
+  "spam_log_id": 42,
+  "captcha_site_key": "6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI",
+  "message": {
+    "error": "Your snippet has been recognized as spam. Please, change the content or solve the reCAPTCHA to proceed."
+  }
+}
+```
+
+**Resolución**:
+
+```bash
+#!/bin/bash
+
+# 1. Obtener CAPTCHA response (Google reCAPTCHA v2)
+# Esto requiere interacción humana en browser
+# https://developers.google.com/recaptcha/docs/display
+
+# 2. Reenviar con headers de CAPTCHA
+CAPTCHA_RESPONSE="<response-from-recaptcha>"
+SPAM_LOG_ID="42"
+
+curl --request POST \
+  --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+  --header "X-GitLab-Captcha-Response: $CAPTCHA_RESPONSE" \
+  --header "X-GitLab-Spam-Log-Id: $SPAM_LOG_ID" \
+  --header "Content-Type: application/json" \
+  --data '{"title": "My snippet", "content": "Content"}' \
+  --url "https://gitlab.example.com/api/v4/snippets"
+```
+
+#### GraphQL - Con CAPTCHA:
+
+```json
+{
+  "errors": [
+    {
+      "message": "Request denied. Solve CAPTCHA challenge and retry",
+      "locations": [{"line": 6, "column": 7}],
+      "path": ["updateSnippet"],
+      "extensions": {
+        "needsCaptchaResponse": true,
+        "captchaSiteKey": "6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI",
+        "spamLogId": 67
+      }
+    }
+  ],
+  "data": {
+    "updateSnippet": {
+      "snippet": null
+    }
+  }
+}
+```
+
+**Resolución**:
+
+```bash
+CAPTCHA_RESPONSE="<response-from-recaptcha>"
+SPAM_LOG_ID="67"
+
+curl --request POST \
+  --header "Authorization: Bearer $GITLAB_TOKEN" \
+  --header "Content-Type: application/json" \
+  --header "X-GitLab-Captcha-Response: $CAPTCHA_RESPONSE" \
+  --header "X-GitLab-Spam-Log-Id: $SPAM_LOG_ID" \
+  --data-binary '{"query": "mutation {updateSnippet(input: {id: \"gid://gitlab/Snippet/123\", title: \"Updated\"}) {snippet {id} errors}}"}' \
+  --url "https://gitlab.com/api/graphql"
+```
+
+---
+
+### Error 404 con Reverse Proxy
+
+**Problema**: URLs con caracteres especiales (/, ?, @) causan 404 cuando hay reverse proxy.
+
+**Causa**: Proxy decodifica URL-encoded characters antes de pasar a GitLab.
+
+**Síntomas**:
+- Editor extensions no funcionan
+- glab CLI falla con paths
+- API calls con URL-encoded params retornan 404
+
+**Solución Apache**:
+
+```apache
+<VirtualHost *:443>
+  ServerName git.example.com
+  
+  # CRÍTICO: Agregar esta línea
+  AllowEncodedSlashes NoDecode
+  
+  <Location />
+    # CRÍTICO: Agregar flag nocanon
+    ProxyPass http://127.0.0.1:8080/ nocanon
+    ProxyPassReverse http://127.0.0.1:8080/
+  </Location>
+</VirtualHost>
+```
+
+**Solución NGINX**:
+
+```nginx
+server {
+  server_name git.example.com;
+  
+  location / {
+    # CRÍTICO: No decodificar automáticamente
+    proxy_pass http://127.0.0.1:8080;
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+  }
+}
+```
+
+**Verificación**:
+
+```bash
+# Debe funcionar sin 404
+curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+  --url "https://git.example.com/api/v4/projects/grupo%2Fproyecto"
+
+# También debe funcionar
+curl --header "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+  --url "https://git.example.com/api/v4/projects/123/repository/files/src%2Fapp.js?ref=main"
+```
+
+---
+
+## Estructura Modular Recomendada
+
+Para organizar una skill operativa de GitLab API, se recomienda la siguiente estructura modular:
+
+```
+gitlab-api-skill/
+├── README.md                          # Índice principal y guía de uso
+├── AUTHENTICATION.md                  # Guía de autenticación (tokens, scopes, headers)
+├── COMMON_PATTERNS.md                 # Patrones comunes (paginación, filtrado, errores)
+├── TROUBLESHOOTING.md                 # Guía de troubleshooting y códigos HTTP
+│
+├── rest/
+│   ├── README.md                      # Introducción a REST API
+│   ├── projects.md                    # Operaciones con proyectos
+│   ├── groups.md                      # Operaciones con grupos
+│   ├── issues.md                      # Operaciones con issues
+│   ├── merge-requests.md              # Operaciones con merge requests
+│   ├── pipelines.md                   # Operaciones con pipelines
+│   ├── jobs.md                        # Operaciones con jobs
+│   ├── repository.md                  # Operaciones con repositorio
+│   ├── files.md                       # Operaciones con archivos
+│   ├── releases.md                    # Operaciones con releases
+│   ├── webhooks.md                    # Operaciones con webhooks
+│   ├── variables.md                   # Operaciones con variables CI/CD
+│   ├── users.md                       # Operaciones con usuarios
+│   ├── labels.md                      # Operaciones con labels
+│   ├── milestones.md                  # Operaciones con milestones
+│   ├── runners.md                     # Operaciones con runners
+│   ├── registry.md                    # Operaciones con container registry
+│   └── deployments.md                 # Operaciones con deployments
+│
+├── graphql/
+│   ├── README.md                      # Introducción a GraphQL API
+│   ├── queries/
+│   │   ├── projects.md                # Queries de proyectos
+│   │   ├── issues.md                  # Queries de issues
+│   │   ├── merge-requests.md          # Queries de merge requests
+│   │   ├── pipelines.md               # Queries de pipelines
+│   │   ├── users.md                   # Queries de usuarios
+│   │   └── advanced.md                # Queries avanzadas (multiplex, complexity)
+│   └── mutations/
+│       ├── projects.md                # Mutations de proyectos
+│       ├── issues.md                  # Mutations de issues
+│       ├── merge-requests.md          # Mutations de merge requests
+│       ├── pipelines.md               # Mutations de pipelines
+│       └── advanced.md                # Mutations avanzadas
+│
+├── glab/
+│   ├── README.md                      # Introducción a glab CLI
+│   ├── setup.md                       # Instalación y configuración
+│   ├── projects.md                    # Comandos de proyectos
+│   ├── issues.md                      # Comandos de issues
+│   ├── merge-requests.md              # Comandos de merge requests
+│   ├── pipelines.md                   # Comandos de pipelines
+│   ├── api.md                         # Uso de glab api
+│   └── scripting.md                   # Scripts y automatización
+│
+├── examples/
+│   ├── bash/
+│   │   ├── create-issue.sh            # Script completo: crear issue
+│   │   ├── create-mr.sh               # Script completo: crear MR
+│   │   ├── trigger-pipeline.sh        # Script completo: ejecutar pipeline
+│   │   ├── bulk-operations.sh         # Script: operaciones en bulk
+│   │   └── monitoring.sh              # Script: monitoreo de pipelines
+│   ├── python/
+│   │   ├── gitlab_client.py           # Cliente Python para GitLab API
+│   │   ├── create_issue.py            # Ejemplo: crear issue
+│   │   ├── create_mr.py               # Ejemplo: crear MR
+│   │   └── pipeline_monitor.py        # Ejemplo: monitorear pipelines
+│   └── graphql/
+│       ├── queries.graphql            # Colección de queries útiles
+│       └── mutations.graphql          # Colección de mutations útiles
+│
+└── reference/
+    ├── status-codes.md                # Referencia completa de códigos HTTP
+    ├── rate-limits.md                 # Información sobre rate limits
+    ├── pagination.md                  # Guía detallada de paginación
+    └── global-ids.md                  # Guía de Global IDs en GraphQL
+```
+
+### Contenido de cada archivo
+
+#### README.md (Principal)
+
+```markdown
+# GitLab API & CLI - Skill Operativa
+
+Guía completa para interactuar con GitLab mediante API REST, GraphQL y CLI (glab).
+
+## Índice
+
+### Guías Generales
+- [Autenticación](AUTHENTICATION.md) - Tokens, scopes, headers
+- [Patrones Comunes](COMMON_PATTERNS.md) - Paginación, filtrado, errores
+- [Troubleshooting](TROUBLESHOOTING.md) - Códigos HTTP y resolución
+
+### REST API
+- [Introducción](rest/README.md)
+- [Projects](rest/projects.md) - Crear, listar, actualizar proyectos
+- [Issues](rest/issues.md) - Gestión de issues
+- [Merge Requests](rest/merge-requests.md) - Gestión de MRs
+- [Pipelines](rest/pipelines.md) - CI/CD pipelines
+- [Jobs](rest/jobs.md) - CI/CD jobs
+- [Repository](rest/repository.md) - Branches, tags, commits
+- [Files](rest/files.md) - Operaciones con archivos
+- [Y más...](rest/)
+
+### GraphQL API
+- [Introducción](graphql/README.md)
+- [Queries](graphql/queries/) - Consultas de datos
+- [Mutations](graphql/mutations/) - Modificaciones de datos
+
+### glab CLI
+- [Introducción](glab/README.md)
+- [Setup](glab/setup.md) - Instalación y configuración
+- [Comandos por feature](glab/)
+
+### Ejemplos
+- [Bash Scripts](examples/bash/)
+- [Python](examples/python/)
+- [GraphQL](examples/graphql/)
+
+### Referencia
+- [Códigos de Estado HTTP](reference/status-codes.md)
+- [Rate Limits](reference/rate-limits.md)
+- [Paginación](reference/pagination.md)
+- [Global IDs](reference/global-ids.md)
+
+## Inicio Rápido
+
+### REST API
+\`\`\`bash
+# Listar proyectos
+curl --header "PRIVATE-TOKEN: <token>" \\
+  --url "https://gitlab.example.com/api/v4/projects"
+\`\`\`
+
+### GraphQL API
+\`\`\`bash
+curl --request POST \\
+  --header "Authorization: Bearer <token>" \\
+  --header "Content-Type: application/json" \\
+  --data '{"query": "query {currentUser {name}}"}' \\
+  --url "https://gitlab.com/api/graphql"
+\`\`\`
+
+### glab CLI
+\`\`\`bash
+# Autenticación
+glab auth login
+
+# Listar issues
+glab issue list
+\`\`\`
+
+## Recursos Oficiales
+
+- [GitLab API Docs](https://docs.gitlab.com/api/)
+- [GraphQL API Reference](https://docs.gitlab.com/api/graphql/reference/)
+- [glab CLI Docs](https://docs.gitlab.com/cli/)
+```
+
+#### rest/projects.md (Ejemplo)
+
+```markdown
+# Projects API - REST
+
+Operaciones con proyectos de GitLab mediante REST API.
+
+## Endpoints
+
+- `GET /projects` - Listar proyectos
+- `GET /projects/:id` - Obtener proyecto
+- `POST /projects` - Crear proyecto
+- `PUT /projects/:id` - Actualizar proyecto
+- `DELETE /projects/:id` - Eliminar proyecto
+- `POST /projects/:id/archive` - Archivar proyecto
+- `POST /projects/:id/unarchive` - Desarchivar proyecto
+
+## Ejemplos
+
+### Listar proyectos
+
+\`\`\`bash
+# Todos los proyectos
+curl --header "PRIVATE-TOKEN: <token>" \\
+  --url "https://gitlab.example.com/api/v4/projects"
+
+# Proyectos propios
+curl --header "PRIVATE-TOKEN: <token>" \\
+  --url "https://gitlab.example.com/api/v4/projects?owned=true"
+
+# Con paginación
+curl --header "PRIVATE-TOKEN: <token>" \\
+  --url "https://gitlab.example.com/api/v4/projects?page=2&per_page=50"
+\`\`\`
+
+### Obtener proyecto
+
+\`\`\`bash
+# Por ID
+curl --header "PRIVATE-TOKEN: <token>" \\
+  --url "https://gitlab.example.com/api/v4/projects/123"
+
+# Por path (URL-encoded)
+curl --header "PRIVATE-TOKEN: <token>" \\
+  --url "https://gitlab.example.com/api/v4/projects/grupo%2Fproyecto"
+\`\`\`
+
+### Crear proyecto
+
+\`\`\`bash
+curl --request POST \\
+  --header "PRIVATE-TOKEN: <token>" \\
+  --header "Content-Type: application/json" \\
+  --data '{
+    "name": "Mi Proyecto",
+    "path": "mi-proyecto",
+    "description": "Descripción",
+    "visibility": "private",
+    "initialize_with_readme": true
+  }' \\
+  --url "https://gitlab.example.com/api/v4/projects"
+\`\`\`
+
+## Ver también
+
+- [Groups](groups.md)
+- [Repository](repository.md)
+- [Troubleshooting](../TROUBLESHOOTING.md)
+```
+
+### Ventajas de esta estructura:
+
+1. **Modularidad**: Cada feature en su propio archivo
+2. **Navegación fácil**: Índice claro en README principal
+3. **Búsqueda rápida**: Archivos organizados por tipo de API
+4. **Ejemplos prácticos**: Scripts completos en carpeta examples/
+5. **Referencia rápida**: Información común en archivos dedicados
+6. **Escalabilidad**: Fácil agregar nuevos endpoints/features
+7. **Mantenimiento**: Actualizar un feature no afecta otros
+8. **Cross-referencing**: Links entre archivos relacionados
+
+### Uso de la estructura:
+
+```bash
+# Buscar cómo crear un issue
+cat rest/issues.md | grep -A 10 "Crear issue"
+
+# Ver todos los ejemplos de bash
+ls examples/bash/
+
+# Buscar información sobre rate limits
+cat reference/rate-limits.md
+
+# Ver troubleshooting de código 404
+cat TROUBLESHOOTING.md | grep -A 20 "404 Not Found"
+```
+
+---
+
+## Conclusión
+
+Esta guía proporciona:
+
+✅ **Resumen completo** de 7 URLs oficiales de GitLab Docs
+✅ **Patrones de uso** para autenticación, paginación, errores y rate limits
+✅ **25+ ejemplos concretos** distribuidos por features (projects, issues, MRs, pipelines, jobs, repository, files, releases, webhooks, variables, GraphQL queries/mutations, glab api)
+✅ **Troubleshooting detallado** con códigos HTTP y resoluciones
+✅ **Estructura modular** recomendada para organizar skill operativa
+
+**Próximos pasos sugeridos:**
+1. Implementar scripts de ejemplo en `examples/bash/`
+2. Crear cliente Python reutilizable en `examples/python/`
+3. Documentar casos de uso específicos por equipo/proyecto
+4. Agregar ejemplos de integración CI/CD
+5. Crear cheatsheet de comandos más usados
+
+---
+
+**Fecha de última actualización**: 18 de febrero de 2026
+**Fuentes**: docs.gitlab.com/api/