mcp-gitlabpr 1.0.0__tar.gz

mcp_gitlabpr-1.0.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+dist/
+.DS_Store
+uv.lock

mcp_gitlabpr-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Xavier Araújo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_gitlabpr-1.0.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: mcp-gitlabpr
+Version: 1.0.0
+Summary: MCP server para merge requests do GitLab (API v4, CE 10.8+): listar, obter e criar
+Project-URL: Repository, https://github.com/dxaraujo/kiro/tree/main/mcps/gitlabpr
+Author-email: Daniel Xavier Araújo <danielxaraujo@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: mcp[cli]>=2.2
+Requires-Dist: requests>=2.31
+Description-Content-Type: text/markdown
+
+# mcp-gitlabpr
+
+Servidor MCP para **merge requests** do GitLab (o "PR" do GitLab): listar, obter (com diffs) e criar. Usa a API REST
+v4 com personal access token e só os parâmetros que já existem na **GitLab CE 10.8**
+([doc da 10.8.7](https://gitlab.com/gitlab-org/gitlab-foss/-/blob/v10.8.7/doc/api/merge_requests.md)), então também
+funciona em versões mais novas.
+
+## Credenciais
+
+| SO | Arquivo |
+|---|---|
+| Linux/Mac | `~/.config/mcp-gitlabpr/gitlabpr.properties` |
+| Windows | `%APPDATA%\mcp-gitlabpr\gitlabpr.properties` |
+
+Para usar outro caminho, defina a variável de ambiente `MCP_GITLABPR_CONFIG`.
+
+```ini
+[DEFAULT]
+url = https://gitlab.SEU-SERVIDOR
+token = SEU_PERSONAL_ACCESS_TOKEN
+```
+
+O token sai de *Settings → Access Tokens* com o escopo `api` e vai no header `PRIVATE-TOKEN`.
+
+**Certificados:** o MCP confia nas CAs da máquina e, se existir, em `gitlabpr-bundle.pem` na mesma pasta do
+`gitlabpr.properties` (cadeia PEM do servidor). `REQUESTS_CA_BUNDLE` também funciona.
+
+## Instalação
+
+```json
+{
+  "mcpServers": {
+    "gitlabpr": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["mcp-gitlabpr@latest"],
+      "env": { "UV_SYSTEM_CERTS": "true" }
+    }
+  }
+}
+```
+
+Desenvolvimento:
+
+```bash
+uv sync
+uv run pytest
+uv run mcp dev mcp_gitlabpr/server.py   # MCP Inspector
+```
+
+## Tools
+
+`projeto` é o caminho `grupo/projeto` (o MCP faz o URL-encode) ou o id numérico. **Sem `projeto`**, ele vem do remote
+do git da pasta em que o MCP roda (`origin`, ou o primeiro remote; aceita `https://`, `ssh://` e `git@host:`), e
+`origem` vem da branch atual. Fora de um repositório git a tool falha pedindo que o agente pergunte ao usuário. O
+cliente MCP precisa iniciar o servidor na pasta do workspace; se não iniciar, informe `projeto`. `iid` é o número do MR no projeto
+(o `!123` da tela). Autor e responsável são usernames: o MCP os converte em id por `GET /users?username=`, porque a 10.8
+só filtra por `author_id`/`assignee_id`.
+
+| Tool | Para quê |
+|---|---|
+| `gitlab_listar_mrs(projeto?, todos_projetos=false, estado=opened, busca?, origem?, destino?, autor?, responsavel?, limite≤100, pagina=1)` | MRs do projeto ou, com `todos_projetos`, de todos os visíveis (`scope=all`). Devolve `total`, `proxima_pagina` e os itens resumidos |
+| `gitlab_obter_mr(iid, projeto?, diffs=false)` | Detalhes do MR (descrição, labels, conflitos, merge). Com `diffs`, os arquivos alterados e o diff de cada um, cortado em 4000 caracteres |
+| `gitlab_criar_mr(titulo, destino, origem?, projeto?, descricao?, responsavel?, labels?, remover_origem=false)` | Cria o MR; a branch de origem precisa já estar no GitLab (`git push`). Se já existe um MR aberto entre as mesmas branches, o GitLab responde 409 |
+
+`estado` aceita `opened`, `closed`, `merged` ou `all`.

mcp_gitlabpr-1.0.0/README.md

@@ -0,0 +1,66 @@
+# mcp-gitlabpr
+
+Servidor MCP para **merge requests** do GitLab (o "PR" do GitLab): listar, obter (com diffs) e criar. Usa a API REST
+v4 com personal access token e só os parâmetros que já existem na **GitLab CE 10.8**
+([doc da 10.8.7](https://gitlab.com/gitlab-org/gitlab-foss/-/blob/v10.8.7/doc/api/merge_requests.md)), então também
+funciona em versões mais novas.
+
+## Credenciais
+
+| SO | Arquivo |
+|---|---|
+| Linux/Mac | `~/.config/mcp-gitlabpr/gitlabpr.properties` |
+| Windows | `%APPDATA%\mcp-gitlabpr\gitlabpr.properties` |
+
+Para usar outro caminho, defina a variável de ambiente `MCP_GITLABPR_CONFIG`.
+
+```ini
+[DEFAULT]
+url = https://gitlab.SEU-SERVIDOR
+token = SEU_PERSONAL_ACCESS_TOKEN
+```
+
+O token sai de *Settings → Access Tokens* com o escopo `api` e vai no header `PRIVATE-TOKEN`.
+
+**Certificados:** o MCP confia nas CAs da máquina e, se existir, em `gitlabpr-bundle.pem` na mesma pasta do
+`gitlabpr.properties` (cadeia PEM do servidor). `REQUESTS_CA_BUNDLE` também funciona.
+
+## Instalação
+
+```json
+{
+  "mcpServers": {
+    "gitlabpr": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["mcp-gitlabpr@latest"],
+      "env": { "UV_SYSTEM_CERTS": "true" }
+    }
+  }
+}
+```
+
+Desenvolvimento:
+
+```bash
+uv sync
+uv run pytest
+uv run mcp dev mcp_gitlabpr/server.py   # MCP Inspector
+```
+
+## Tools
+
+`projeto` é o caminho `grupo/projeto` (o MCP faz o URL-encode) ou o id numérico. **Sem `projeto`**, ele vem do remote
+do git da pasta em que o MCP roda (`origin`, ou o primeiro remote; aceita `https://`, `ssh://` e `git@host:`), e
+`origem` vem da branch atual. Fora de um repositório git a tool falha pedindo que o agente pergunte ao usuário. O
+cliente MCP precisa iniciar o servidor na pasta do workspace; se não iniciar, informe `projeto`. `iid` é o número do MR no projeto
+(o `!123` da tela). Autor e responsável são usernames: o MCP os converte em id por `GET /users?username=`, porque a 10.8
+só filtra por `author_id`/`assignee_id`.
+
+| Tool | Para quê |
+|---|---|
+| `gitlab_listar_mrs(projeto?, todos_projetos=false, estado=opened, busca?, origem?, destino?, autor?, responsavel?, limite≤100, pagina=1)` | MRs do projeto ou, com `todos_projetos`, de todos os visíveis (`scope=all`). Devolve `total`, `proxima_pagina` e os itens resumidos |
+| `gitlab_obter_mr(iid, projeto?, diffs=false)` | Detalhes do MR (descrição, labels, conflitos, merge). Com `diffs`, os arquivos alterados e o diff de cada um, cortado em 4000 caracteres |
+| `gitlab_criar_mr(titulo, destino, origem?, projeto?, descricao?, responsavel?, labels?, remover_origem=false)` | Cria o MR; a branch de origem precisa já estar no GitLab (`git push`). Se já existe um MR aberto entre as mesmas branches, o GitLab responde 409 |
+
+`estado` aceita `opened`, `closed`, `merged` ou `all`.

mcp_gitlabpr-1.0.0/mcp_gitlabpr/config.py

@@ -0,0 +1,42 @@
+"""Carrega URL e token do GitLab a partir de gitlabpr.properties."""
+from __future__ import annotations
+
+import configparser
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+REQUIRED = ("url", "token")
+TEMPLATE = "[DEFAULT]\nurl = https://gitlab.SEU-SERVIDOR\ntoken = SEU_PERSONAL_ACCESS_TOKEN"
+
+
+@dataclass(frozen=True)
+class GitlabConfig:
+    url: str
+    token: str = field(repr=False)
+
+
+def default_path() -> Path:
+    if env := os.environ.get("MCP_GITLABPR_CONFIG"):
+        return Path(env)
+    if sys.platform == "win32":
+        return Path(os.environ["APPDATA"]) / "mcp-gitlabpr" / "gitlabpr.properties"
+    return Path.home() / ".config" / "mcp-gitlabpr" / "gitlabpr.properties"
+
+
+def load_config(path: Path | None = None) -> GitlabConfig:
+    path = path or default_path()
+    if not path.is_file():
+        raise FileNotFoundError(f"Arquivo de credenciais não encontrado: {path}\nCrie-o com:\n{TEMPLATE}")
+    # interpolation=None: tokens podem conter '%'
+    parser = configparser.ConfigParser(interpolation=None)
+    try:
+        parser.read(path, encoding="utf-8")
+    except configparser.Error as exc:
+        raise ValueError(f"{path} inválido: {exc}") from exc
+    section = parser.defaults()
+    missing = [k for k in REQUIRED if not section.get(k, "").strip()]
+    if missing:
+        raise ValueError(f"Chave(s) ausente(s) em {path} [DEFAULT]: {', '.join(missing)}")
+    return GitlabConfig(url=section["url"].strip().rstrip("/"), token=section["token"].strip())

mcp_gitlabpr-1.0.0/mcp_gitlabpr/server.py

@@ -0,0 +1,283 @@
+"""Servidor MCP para merge requests do GitLab: listar, obter (com diffs) e criar.
+
+API REST v4 com personal access token (header PRIVATE-TOKEN, escopo `api`). Só usa parâmetros que já existem na
+GitLab CE 10.8: autor e responsável vão por id (`author_username` é de versões novas), resolvidos por username.
+
+Sem `projeto`, ele vem do remote do git da pasta em que o MCP roda (origin, ou o primeiro remote).
+"""
+from __future__ import annotations
+
+import functools
+import ssl
+import subprocess
+import threading
+from pathlib import Path
+from urllib.parse import quote, urlsplit
+
+import requests
+from requests.adapters import HTTPAdapter
+from mcp.server.mcpserver import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
+
+from .config import GitlabConfig, default_path, load_config
+
+mcp = MCPServer(
+    "gitlabpr",
+    instructions=(
+        "Merge requests (MR, o 'PR' do GitLab). `projeto` é o caminho 'grupo/projeto' ou o id numérico; sem ele, vem "
+        "do remote do repositório git da pasta atual e `origem` vem da branch atual. Fora de um repositório git a tool "
+        "falha: pergunte ao usuário o projeto (e a branch de origem) e informe-os. `iid` é o número do MR dentro do "
+        "projeto (o !123 da tela). Autor e responsável são usernames. Liste com "
+        "gitlab_listar_mrs, detalhe (e veja os diffs) com gitlab_obter_mr, crie com gitlab_criar_mr."
+    ),
+)
+
+EXPECTED = (RuntimeError, OSError, LookupError, ValueError)
+TIMEOUT = 60
+LIMITE_TETO = 100
+DIFF_MAX = 4000
+ESTADOS = ("opened", "closed", "merged", "all")
+
+
+def tool(fn):
+    """Registra `fn` como tool (ToolError com o texto da exceção) e devolve `fn` intacta."""
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except EXPECTED as exc:
+            raise ToolError(str(exc)) from exc
+
+    mcp.tool()(wrapper)
+    return fn
+
+
+# ---------------------------------------------------------------- HTTP
+
+def ca_bundle() -> Path:
+    """CAs extras (ex.: cadeia interna do GitLab), ao lado do gitlabpr.properties."""
+    return default_path().parent / "gitlabpr-bundle.pem"
+
+
+class _TlsAdapter(HTTPAdapter):
+    """CAs do sistema + gitlabpr-bundle.pem, se existir."""
+
+    def init_poolmanager(self, *args, **kwargs):
+        ctx = ssl.create_default_context()
+        if ca_bundle().is_file():
+            ctx.load_verify_locations(ca_bundle())
+        super().init_poolmanager(*args, ssl_context=ctx, **kwargs)
+
+
+class GitlabSession:
+    def __init__(self, cfg: GitlabConfig):
+        self.cfg = cfg
+        self.api = f"{cfg.url}/api/v4"
+        self.session = requests.Session()
+        self.session.mount("https://", _TlsAdapter())
+        self.session.headers.update({"PRIVATE-TOKEN": cfg.token, "Accept": "application/json"})
+
+    def request(self, method: str, path: str, **kwargs) -> requests.Response:
+        url = self.api + path
+        try:
+            resp = self.session.request(method, url, timeout=TIMEOUT, **kwargs)
+        except requests.exceptions.SSLError as exc:
+            raise RuntimeError(
+                f"Certificado do servidor não confiável em {url}. Grave a cadeia de certificados (PEM) em "
+                f"{ca_bundle()} (ou aponte REQUESTS_CA_BUNDLE para ela) e reinicie o MCP. Detalhe: {exc}") from exc
+        if resp.status_code == 401:
+            raise RuntimeError(f"HTTP 401 em {method} {url}: token inválido ou expirado (precisa do escopo `api`).")
+        if not resp.ok:
+            raise RuntimeError(f"HTTP {resp.status_code} em {method} {url}: {resp.text[:500].strip()}")
+        return resp
+
+
+_instance: GitlabSession | None = None
+_lock = threading.Lock()
+
+
+def get_session() -> GitlabSession:
+    """Sessão única por processo; carrega o gitlabpr.properties na primeira chamada."""
+    global _instance
+    with _lock:
+        if _instance is None:
+            _instance = GitlabSession(load_config())
+        return _instance
+
+
+def set_session(session: GitlabSession | None) -> None:
+    """Substitui a sessão global (testes)."""
+    global _instance
+    _instance = session
+
+
+# ---------------------------------------------------------------- helpers
+
+# ponytail: usa o cwd do processo MCP; se o cliente não o iniciar na pasta do workspace, informe `projeto`
+def _git(*args: str) -> str | None:
+    try:
+        r = subprocess.run(["git", *args], capture_output=True, text=True, timeout=10)
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return (r.stdout.strip() or None) if r.returncode == 0 else None
+
+
+def _caminho_remoto(url: str) -> str:
+    """'grupo/projeto' de https://host[/prefixo]/g/p.git, ssh://git@host:22/g/p.git ou git@host:g/p.git."""
+    if "://" in url:
+        path = urlsplit(url).path
+        prefixo = urlsplit(get_session().cfg.url).path.rstrip("/")  # GitLab sob subcaminho (https://host/gitlab)
+        if prefixo and path.startswith(prefixo + "/") and url.startswith(("http://", "https://")):
+            path = path[len(prefixo):]
+    else:
+        path = url.partition(":")[2]
+    path = path.strip("/")
+    return path[:-4] if path.endswith(".git") else path
+
+
+def _projeto(projeto: str | int | None) -> str:
+    """'grupo/projeto' vai URL-encoded no path (grupo%2Fprojeto); id numérico passa como está; sem ele, o remote do git."""
+    p = str(projeto).strip().strip("/") if projeto is not None else ""
+    if not p:
+        remotes = (_git("remote") or "").split()
+        remote = "origin" if "origin" in remotes else (remotes[0] if remotes else None)
+        url = remote and _git("remote", "get-url", remote)
+        if not url:
+            raise ValueError("Pasta atual não é um repositório git com remote: pergunte ao usuário o projeto "
+                             "('grupo/projeto' ou id numérico) e informe-o em `projeto`.")
+        p = _caminho_remoto(url)
+    return quote(p, safe="")
+
+
+def _branch_atual() -> str:
+    branch = _git("rev-parse", "--abbrev-ref", "HEAD")
+    if not branch or branch == "HEAD":
+        raise ValueError("Sem branch atual no git (fora de um repositório ou HEAD destacado): pergunte ao usuário a "
+                         "branch de origem e informe-a em `origem`.")
+    return branch
+
+
+def _usuario_id(username: str) -> int:
+    nome = username.strip().lstrip("@")
+    users = get_session().request("GET", "/users", params={"username": nome}).json()
+    if not users:
+        raise LookupError(f"Usuário '{nome}' não encontrado no GitLab.")
+    return users[0]["id"]
+
+
+def _login(user: dict | None) -> str | None:
+    return user and user.get("username")
+
+
+def _resumo(mr: dict) -> dict:
+    return {
+        "iid": mr["iid"],
+        "projeto_id": mr.get("project_id"),
+        "titulo": mr.get("title"),
+        "estado": mr.get("state"),
+        "origem": mr.get("source_branch"),
+        "destino": mr.get("target_branch"),
+        "autor": _login(mr.get("author")),
+        "responsavel": _login(mr.get("assignee")),
+        "wip": mr.get("work_in_progress"),
+        "merge_status": mr.get("merge_status"),
+        "criado_em": mr.get("created_at"),
+        "atualizado_em": mr.get("updated_at"),
+        "url": mr.get("web_url"),
+    }
+
+
+# ---------------------------------------------------------------- tools
+
+@tool
+def gitlab_listar_mrs(projeto: str | None = None, todos_projetos: bool = False, estado: str = "opened",
+                      busca: str | None = None, origem: str | None = None, destino: str | None = None,
+                      autor: str | None = None, responsavel: str | None = None, limite: int = 20,
+                      pagina: int = 1) -> dict:
+    """Lista merge requests de `projeto` ('grupo/projeto' ou id; sem ele, o do repositório git atual) ou, com
+    todos_projetos=True, de todos os projetos visíveis.
+
+    estado: opened (padrão), closed, merged ou all. busca: texto no título/descrição.
+    origem/destino: branches. autor/responsavel: usernames. limite ≤ 100 por página.
+    """
+    if estado not in ESTADOS:
+        raise ValueError(f"estado inválido: '{estado}'. Use {', '.join(ESTADOS)}.")
+    params = {"state": estado, "per_page": max(1, min(limite, LIMITE_TETO)), "page": max(1, pagina),
+              "order_by": "updated_at", "sort": "desc"}
+    if busca:
+        params["search"] = busca
+    if origem:
+        params["source_branch"] = origem
+    if destino:
+        params["target_branch"] = destino
+    if autor:
+        params["author_id"] = _usuario_id(autor)
+    if responsavel:
+        params["assignee_id"] = _usuario_id(responsavel)
+    if todos_projetos:
+        path, params["scope"] = "/merge_requests", "all"  # padrão do endpoint global é created-by-me
+    else:
+        path = f"/projects/{_projeto(projeto)}/merge_requests"
+    resp = get_session().request("GET", path, params=params)
+    return {
+        "total": int(resp.headers["X-Total"]) if resp.headers.get("X-Total") else None,
+        "pagina": params["page"],
+        "proxima_pagina": int(resp.headers["X-Next-Page"]) if resp.headers.get("X-Next-Page") else None,
+        "itens": [_resumo(mr) for mr in resp.json()],
+    }
+
+
+@tool
+def gitlab_obter_mr(iid: int, projeto: str | None = None, diffs: bool = False) -> dict:
+    """Detalhes de um merge request (descrição, labels, merge); `projeto` padrão: o do repositório git atual.
+    Com diffs=True, inclui os arquivos alterados e o diff de cada um (cortado em 4000 caracteres)."""
+    base = f"/projects/{_projeto(projeto)}/merge_requests/{int(iid)}"
+    mr = get_session().request("GET", base + ("/changes" if diffs else "")).json()
+    out = _resumo(mr) | {
+        "descricao": mr.get("description"),
+        "labels": mr.get("labels"),
+        "conflitos": mr.get("has_conflicts"),
+        "remover_origem": mr.get("force_remove_source_branch"),
+        "mesclado_por": _login(mr.get("merged_by")),
+        "mesclado_em": mr.get("merged_at"),
+        "sha": mr.get("sha"),
+    }
+    if diffs:
+        out["arquivos"] = [{
+            "caminho": c.get("new_path"),
+            "caminho_anterior": c.get("old_path") if c.get("renamed_file") else None,
+            "novo": c.get("new_file"),
+            "removido": c.get("deleted_file"),
+            "diff": c.get("diff", "")[:DIFF_MAX],
+            "diff_cortado": len(c.get("diff", "")) > DIFF_MAX,
+        } for c in mr.get("changes", [])]
+    return out
+
+
+@tool
+def gitlab_criar_mr(titulo: str, destino: str, origem: str | None = None, projeto: str | None = None,
+                    descricao: str | None = None, responsavel: str | None = None, labels: list[str] | None = None,
+                    remover_origem: bool = False) -> dict:
+    """Cria um merge request de `origem` (padrão: branch atual do git) para `destino` no `projeto` (padrão: o do
+    repositório git atual). A branch de origem precisa estar no GitLab (git push). responsavel: username.
+    remover_origem: apaga a branch de origem após o merge. Falha (HTTP 409) se já existe MR aberto entre as branches."""
+    if not titulo.strip():
+        raise ValueError("Informe `titulo`.")
+    data = {"source_branch": origem or _branch_atual(), "target_branch": destino, "title": titulo,
+            "remove_source_branch": remover_origem}
+    if descricao:
+        data["description"] = descricao
+    if responsavel:
+        data["assignee_id"] = _usuario_id(responsavel)
+    if labels:
+        data["labels"] = ",".join(labels)
+    mr = get_session().request("POST", f"/projects/{_projeto(projeto)}/merge_requests", json=data).json()
+    return _resumo(mr)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

mcp_gitlabpr-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "mcp-gitlabpr"
+version = "1.0.0"
+description = "MCP server para merge requests do GitLab (API v4, CE 10.8+): listar, obter e criar"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Daniel Xavier Araújo", email = "danielxaraujo@gmail.com" }]
+requires-python = ">=3.10"
+dependencies = [
+    "mcp[cli]>=2.2",
+    "requests>=2.31",
+]
+
+[project.urls]
+Repository = "https://github.com/dxaraujo/kiro/tree/main/mcps/gitlabpr"
+
+[project.scripts]
+mcp-gitlabpr = "mcp_gitlabpr.server:main"
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

mcp_gitlabpr-1.0.0/tests/test_server.py

@@ -0,0 +1,132 @@
+import json
+import subprocess
+
+import pytest
+import requests
+from requests.adapters import BaseAdapter
+
+from mcp_gitlabpr import config, server
+from mcp_gitlabpr.config import GitlabConfig
+
+API = "https://gitlab.test/api/v4"
+MR = {"iid": 7, "project_id": 3, "title": "Ajuste", "state": "opened", "source_branch": "feat", "target_branch": "dev",
+      "author": {"username": "joao"}, "assignee": None, "web_url": "https://gitlab.test/g/p/merge_requests/7"}
+
+
+class FakeAdapter(BaseAdapter):
+    """routes: {(METODO, url_sem_query): (status, body, headers?)}."""
+
+    def __init__(self):
+        super().__init__()
+        self.routes = {}
+        self.calls: list[requests.PreparedRequest] = []
+
+    def send(self, request, **kwargs):
+        self.calls.append(request)
+        status, body, *headers = self.routes.get((request.method, request.url.split("?")[0]), (404, "not found"))
+        resp = requests.Response()
+        resp.status_code = status
+        resp._content = json.dumps(body).encode()
+        resp.headers.update(headers[0] if headers else {})
+        resp.url, resp.request = request.url, request
+        return resp
+
+    def close(self):
+        pass
+
+
+@pytest.fixture
+def fake():
+    adapter = FakeAdapter()
+    session = server.GitlabSession(GitlabConfig(url="https://gitlab.test", token="tok"))
+    session.session.mount("https://", adapter)
+    server.set_session(session)
+    yield adapter
+    server.set_session(None)
+
+
+def test_config(tmp_path):
+    with pytest.raises(FileNotFoundError):
+        config.load_config(tmp_path / "x")
+    p = tmp_path / "gitlabpr.properties"
+    p.write_text("[DEFAULT]\nurl = https://gitlab.test/\n")
+    with pytest.raises(ValueError, match="token"):
+        config.load_config(p)
+    p.write_text("[DEFAULT]\nurl = https://gitlab.test/\ntoken = a%b\n")
+    assert config.load_config(p) == GitlabConfig(url="https://gitlab.test", token="a%b")
+
+
+def test_listar_projeto(fake):
+    fake.routes[("GET", f"{API}/users")] = (200, [{"id": 42}])
+    fake.routes[("GET", f"{API}/projects/g%2Fp/merge_requests")] = (200, [MR], {"X-Total": "1"})
+    out = server.gitlab_listar_mrs("g/p", autor="@joao", destino="dev", limite=500)
+    req = fake.calls[-1]
+    assert req.headers["PRIVATE-TOKEN"] == "tok"
+    assert "author_id=42" in req.url and "target_branch=dev" in req.url and "per_page=100" in req.url
+    assert out["total"] == 1 and out["proxima_pagina"] is None
+    assert out["itens"][0] | {} == server._resumo(MR) and out["itens"][0]["autor"] == "joao"
+
+
+def test_listar_global_usa_scope_all(fake):
+    fake.routes[("GET", f"{API}/merge_requests")] = (200, [])
+    server.gitlab_listar_mrs(todos_projetos=True)
+    assert "scope=all" in fake.calls[-1].url
+    with pytest.raises(ValueError):
+        server.gitlab_listar_mrs("g/p", estado="aberto")
+
+
+def test_obter_com_diffs(fake):
+    change = {"new_path": "a.py", "old_path": "a.py", "diff": "x" * 5000}
+    fake.routes[("GET", f"{API}/projects/3/merge_requests/7/changes")] = (200, MR | {"changes": [change]})
+    out = server.gitlab_obter_mr(7, projeto=3, diffs=True)
+    assert out["arquivos"][0]["diff_cortado"] and len(out["arquivos"][0]["diff"]) == server.DIFF_MAX
+
+
+def test_criar(fake):
+    fake.routes[("GET", f"{API}/users")] = (200, [{"id": 9}])
+    fake.routes[("POST", f"{API}/projects/g%2Fp/merge_requests")] = (201, MR)
+    out = server.gitlab_criar_mr("Ajuste", "dev", "feat", "g/p", responsavel="maria", labels=["a", "b"])
+    assert json.loads(fake.calls[-1].body) == {"source_branch": "feat", "target_branch": "dev", "title": "Ajuste",
+                                               "remove_source_branch": False, "assignee_id": 9, "labels": "a,b"}
+    assert out["iid"] == 7
+
+
+def test_erros(fake):
+    fake.routes[("GET", f"{API}/users")] = (200, [])
+    with pytest.raises(LookupError):
+        server.gitlab_criar_mr("t", "dev", "feat", "g/p", responsavel="ninguem")
+    fake.routes[("POST", f"{API}/projects/g%2Fp/merge_requests")] = (409, {"message": ["Another open merge request"]})
+    with pytest.raises(RuntimeError, match="409"):
+        server.gitlab_criar_mr("t", "dev", "feat", "g/p")
+    fake.routes[("GET", f"{API}/projects/g%2Fp/merge_requests/1")] = (401, {"message": "401 Unauthorized"})
+    with pytest.raises(RuntimeError, match="token"):
+        server.gitlab_obter_mr(1, "g/p")
+
+
+@pytest.mark.parametrize("url", ["https://gitlab.test/g/sub/p.git", "git@gitlab.test:g/sub/p.git",
+                                 "ssh://git@gitlab.test:2222/g/sub/p.git", "https://gitlab.test/g/sub/p"])
+def test_caminho_remoto(fake, url):
+    assert server._caminho_remoto(url) == "g/sub/p"
+
+
+def test_caminho_remoto_subcaminho(fake):
+    server.set_session(server.GitlabSession(GitlabConfig(url="https://host/gitlab", token="t")))
+    assert server._caminho_remoto("https://host/gitlab/g/p.git") == "g/p"
+
+
+def git(*args):
+    subprocess.run(["git", *args], check=True, capture_output=True)
+
+
+def test_projeto_e_branch_do_git(fake, tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    with pytest.raises(ValueError, match="pergunte ao usuário o projeto"):
+        server.gitlab_listar_mrs()
+    with pytest.raises(ValueError, match="pergunte ao usuário a branch"):
+        server.gitlab_criar_mr("t", "dev")
+    git("init", "-q", "-b", "feat")
+    git("-c", "user.name=t", "-c", "user.email=t@t", "commit", "-q", "--allow-empty", "-m", "x")
+    git("remote", "add", "origin", "git@gitlab.test:g/p.git")
+    fake.routes[("POST", f"{API}/projects/g%2Fp/merge_requests")] = (201, MR)
+    server.gitlab_criar_mr("t", "dev")
+    assert json.loads(fake.calls[-1].body)["source_branch"] == "feat"