mcp-gitlabpr 1.0.0__tar.gz → 1.0.2__tar.gz

{mcp_gitlabpr-1.0.0 → mcp_gitlabpr-1.0.2}/.gitignore

@@ -2,6 +2,7 @@ __pycache__/
 *.pyc
 .venv/
 .pytest_cache/
+.superpowers/
 dist/
 .DS_Store
-uv.lock
+uv.lock

mcp_gitlabpr-1.0.2/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.5
+Name: mcp-gitlabpr
+Version: 1.0.2
+Summary: MCP server para merge requests do GitLab (API v4, CE 10.8+): listar, obter, criar e mesclar, só no projeto do workspace
+Project-URL: Repository, https://github.com/dxaraujo/mcp-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), criar e mesclar. 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
+
+As tools só trabalham no **projeto do workspace**: não há como consultar outro projeto nem MRs de todos os projetos.
+O projeto vem do remote do git (`origin`, ou o primeiro remote; aceita `https://`, `ssh://` e `git@host:`) da `pasta`
+informada, o caminho absoluto da raiz do workspace, e `origem` vem da branch atual dela. O agente deve passar `pasta`
+sempre: o Kiro não inicia o MCP de um power na pasta do workspace, e sem `pasta` vale o cwd do processo. Fora de um
+repositório, a pessoa cola a URL do projeto no GitLab (ex.: `https://gitlab.SEU-SERVIDOR/grupo/projeto`; a URL de um MR do
+projeto também serve) e o agente a passa em `url_projeto`; aí `origem` é obrigatória no `gitlab_criar_mr`. O host do
+remote ou da URL precisa ser o do `gitlabpr.properties`; se não for, a tool recusa. `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(pasta?, url_projeto?, estado=opened, busca?, origem?, destino?, autor?, responsavel?, limite≤100, pagina=1)` | MRs do projeto. Devolve `total`, `proxima_pagina` e os itens resumidos |
+| `gitlab_obter_mr(iid, pasta?, url_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, pasta?, url_projeto?, origem?, descricao?, responsavel?, labels?, remover_origem=true)` | Cria o MR, já com "apagar a branch de origem após o merge" marcado (passe `remover_origem=false` para manter a branch); 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 |
+| `gitlab_mesclar_mr(iid, pasta?, url_projeto?, sha?, remover_origem?, mensagem?)` | Faz o merge de um MR aberto; recusa antes de chamar o GitLab se ele está em WIP, tem conflito ou não é mesclável. Com `sha`, o GitLab recusa (409) se a branch recebeu commits depois desse commit |
+
+`estado` aceita `opened`, `closed`, `merged` ou `all`.

mcp_gitlabpr-1.0.2/README.md

@@ -0,0 +1,70 @@
+# mcp-gitlabpr
+
+Servidor MCP para **merge requests** do GitLab (o "PR" do GitLab): listar, obter (com diffs), criar e mesclar. 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
+
+As tools só trabalham no **projeto do workspace**: não há como consultar outro projeto nem MRs de todos os projetos.
+O projeto vem do remote do git (`origin`, ou o primeiro remote; aceita `https://`, `ssh://` e `git@host:`) da `pasta`
+informada, o caminho absoluto da raiz do workspace, e `origem` vem da branch atual dela. O agente deve passar `pasta`
+sempre: o Kiro não inicia o MCP de um power na pasta do workspace, e sem `pasta` vale o cwd do processo. Fora de um
+repositório, a pessoa cola a URL do projeto no GitLab (ex.: `https://gitlab.SEU-SERVIDOR/grupo/projeto`; a URL de um MR do
+projeto também serve) e o agente a passa em `url_projeto`; aí `origem` é obrigatória no `gitlab_criar_mr`. O host do
+remote ou da URL precisa ser o do `gitlabpr.properties`; se não for, a tool recusa. `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(pasta?, url_projeto?, estado=opened, busca?, origem?, destino?, autor?, responsavel?, limite≤100, pagina=1)` | MRs do projeto. Devolve `total`, `proxima_pagina` e os itens resumidos |
+| `gitlab_obter_mr(iid, pasta?, url_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, pasta?, url_projeto?, origem?, descricao?, responsavel?, labels?, remover_origem=true)` | Cria o MR, já com "apagar a branch de origem após o merge" marcado (passe `remover_origem=false` para manter a branch); 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 |
+| `gitlab_mesclar_mr(iid, pasta?, url_projeto?, sha?, remover_origem?, mensagem?)` | Faz o merge de um MR aberto; recusa antes de chamar o GitLab se ele está em WIP, tem conflito ou não é mesclável. Com `sha`, o GitLab recusa (409) se a branch recebeu commits depois desse commit |
+
+`estado` aceita `opened`, `closed`, `merged` ou `all`.

{mcp_gitlabpr-1.0.0 → mcp_gitlabpr-1.0.2}/mcp_gitlabpr/server.py

@@ -1,9 +1,11 @@
-"""Servidor MCP para merge requests do GitLab: listar, obter (com diffs) e criar.
+"""Servidor MCP para merge requests do GitLab: listar, obter (com diffs), criar e mesclar.
 
 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).
+Só trabalha no projeto do repositório git do workspace (`pasta`; sem ela, a pasta em que o MCP roda), pelo remote
+origin ou o primeiro remote. Fora de um repositório, a pessoa cola a URL do projeto no GitLab (`url_projeto`). O host
+precisa ser o do gitlabpr.properties.
 """
 from __future__ import annotations
 
@@ -24,11 +26,13 @@ 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."
+        "Merge requests (MR, o 'PR' do GitLab) só do projeto em que se está trabalhando: ele vem do remote do "
+        "repositório git em `pasta` e `origem` vem da branch atual dele. Informe sempre `pasta` com o caminho absoluto "
+        "da raiz do workspace. Se a tool disser que não achou o projeto, peça à pessoa a URL do projeto no GitLab "
+        "(ex.: https://gitlab/grupo/projeto) e informe-a em `url_projeto`; nunca a deduza nem a invente. `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 e faça o merge com gitlab_mesclar_mr."
     ),
 )
 
@@ -113,10 +117,12 @@ def set_session(session: GitlabSession | None) -> None:
 
 # ---------------------------------------------------------------- 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:
+def _git(pasta: str | None, *args: str) -> str | None:
+    """git na `pasta` do workspace; sem ela, no cwd do processo MCP (o Kiro não inicia o de um power no workspace)."""
+    if pasta and not Path(pasta).is_dir():
+        raise ValueError(f"`pasta` não existe: {pasta}. Informe o caminho absoluto da raiz do workspace.")
     try:
-        r = subprocess.run(["git", *args], capture_output=True, text=True, timeout=10)
+        r = subprocess.run(["git", *args], capture_output=True, text=True, timeout=10, cwd=pasta or None)
     except (OSError, subprocess.TimeoutExpired):
         return None
     return (r.stdout.strip() or None) if r.returncode == 0 else None
@@ -124,9 +130,13 @@ def _git(*args: str) -> str | 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."""
+    gitlab = urlsplit(get_session().cfg.url)
+    host = urlsplit(url).hostname if "://" in url else url.partition(":")[0].rpartition("@")[2]
+    if (host or "").lower() != (gitlab.hostname or "").lower():
+        raise ValueError(f"O remote do repositório ({url}) não é do GitLab configurado ({get_session().cfg.url}).")
     if "://" in url:
         path = urlsplit(url).path
-        prefixo = urlsplit(get_session().cfg.url).path.rstrip("/")  # GitLab sob subcaminho (https://host/gitlab)
+        prefixo = gitlab.path.rstrip("/")  # GitLab sob subcaminho (https://host/gitlab)
         if prefixo and path.startswith(prefixo + "/") and url.startswith(("http://", "https://")):
             path = path[len(prefixo):]
     else:
@@ -135,22 +145,26 @@ def _caminho_remoto(url: str) -> str:
     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")
+def _projeto(pasta: str | None, url_projeto: str | None = None) -> str:
+    """'grupo/projeto' da URL colada pela pessoa ou do remote do git, URL-encoded para o path (grupo%2Fprojeto)."""
+    if url_projeto:
+        url = url_projeto.strip()
+        if not url.startswith(("https://", "http://")):
+            raise ValueError(f"`url_projeto` precisa ser a URL do projeto no GitLab (https://...): {url}")
+        url = url.split("/-/")[0].split("/merge_requests")[0]  # aceita a URL de um MR ou de uma página do projeto
+        return quote(_caminho_remoto(url), safe="")
+    remotes = (_git(pasta, "remote") or "").split()
+    remote = "origin" if "origin" in remotes else (remotes[0] if remotes else None)
+    url = remote and _git(pasta, "remote", "get-url", remote)
+    if not url:
+        raise ValueError(f"Projeto não encontrado: {pasta or Path.cwd()} não é um repositório git com remote. Informe "
+                         "em `pasta` a raiz do workspace ou peça à pessoa a URL do projeto no GitLab e informe-a em "
+                         "`url_projeto`.")
+    return quote(_caminho_remoto(url), safe="")
+
+
+def _branch_atual(pasta: str | None) -> str:
+    branch = _git(pasta, "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`.")
@@ -190,12 +204,12 @@ def _resumo(mr: dict) -> dict:
 # ---------------------------------------------------------------- tools
 
 @tool
-def gitlab_listar_mrs(projeto: str | None = None, todos_projetos: bool = False, estado: str = "opened",
+def gitlab_listar_mrs(pasta: str | None = None, url_projeto: str | None = None, 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.
+    """Lista merge requests do projeto do repositório git em `pasta` (caminho absoluto da raiz do workspace) ou
+    de `url_projeto` (a URL do projeto no GitLab, colada pela pessoa).
 
     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.
@@ -214,11 +228,7 @@ def gitlab_listar_mrs(projeto: str | None = None, todos_projetos: bool = False,
         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)
+    resp = get_session().request("GET", f"/projects/{_projeto(pasta, url_projeto)}/merge_requests", params=params)
     return {
         "total": int(resp.headers["X-Total"]) if resp.headers.get("X-Total") else None,
         "pagina": params["page"],
@@ -228,10 +238,10 @@ def gitlab_listar_mrs(projeto: str | None = None, todos_projetos: bool = False,
 
 
 @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.
+def gitlab_obter_mr(iid: int, pasta: str | None = None, url_projeto: str | None = None, diffs: bool = False) -> dict:
+    """Detalhes de um merge request do projeto do repositório git em `pasta` (descrição, labels, merge).
     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)}"
+    base = f"/projects/{_projeto(pasta, url_projeto)}/merge_requests/{int(iid)}"
     mr = get_session().request("GET", base + ("/changes" if diffs else "")).json()
     out = _resumo(mr) | {
         "descricao": mr.get("description"),
@@ -255,15 +265,17 @@ def gitlab_obter_mr(iid: int, projeto: str | None = None, diffs: bool = False) -
 
 
 @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."""
+def gitlab_criar_mr(titulo: str, destino: str, pasta: str | None = None, url_projeto: str | None = None,
+                    origem: str | None = None, descricao: str | None = None, responsavel: str | None = None,
+                    labels: list[str] | None = None, remover_origem: bool = True) -> dict:
+    """Cria um merge request de `origem` (padrão: branch atual do git) para `destino` no projeto do repositório
+    git em `pasta`. A branch de origem precisa estar no GitLab (git push). responsavel: username.
+    remover_origem (padrão: sim): o MR já nasce com 'apagar a branch de origem após o merge' marcado; passe False para manter a branch. 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,
+    if url_projeto and not origem:
+        raise ValueError("Com `url_projeto`, pergunte ao usuário a branch de origem e informe-a em `origem`.")
+    data = {"source_branch": origem or _branch_atual(pasta), "target_branch": destino, "title": titulo,
             "remove_source_branch": remover_origem}
     if descricao:
         data["description"] = descricao
@@ -271,10 +283,37 @@ def gitlab_criar_mr(titulo: str, destino: str, origem: str | None = None, projet
         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()
+    mr = get_session().request("POST", f"/projects/{_projeto(pasta, url_projeto)}/merge_requests", json=data).json()
     return _resumo(mr)
 
 
+@tool
+def gitlab_mesclar_mr(iid: int, pasta: str | None = None, url_projeto: str | None = None, sha: str | None = None,
+                      remover_origem: bool | None = None, mensagem: str | None = None) -> dict:
+    """Faz o merge de um merge request aberto do projeto do repositório git em `pasta`. Antes confere que ele não
+    está em WIP, não tem conflito e que o GitLab o considera mesclável. sha: o commit aprovado; se a branch recebeu
+    commits depois, o GitLab recusa (HTTP 409). remover_origem: apaga a branch de origem (padrão: o que o MR já
+    define). mensagem: do commit de merge."""
+    base = f"/projects/{_projeto(pasta, url_projeto)}/merge_requests/{int(iid)}"
+    mr = get_session().request("GET", base).json()
+    if mr.get("state") != "opened":
+        raise ValueError(f"MR !{iid} não está aberto (estado: {mr.get('state')}).")
+    if mr.get("work_in_progress"):
+        raise ValueError(f"MR !{iid} está em WIP/Draft: tire o prefixo antes do merge.")
+    if mr.get("has_conflicts") or mr.get("merge_status") == "cannot_be_merged":
+        raise ValueError(f"MR !{iid} tem conflito com {mr.get('target_branch')}: atualize a branch antes do merge.")
+    data = {}
+    if sha:
+        data["sha"] = sha
+    if remover_origem is not None:
+        data["should_remove_source_branch"] = remover_origem
+    if mensagem:
+        data["merge_commit_message"] = mensagem
+    mr = get_session().request("PUT", base + "/merge", json=data).json()
+    return _resumo(mr) | {"mesclado_por": _login(mr.get("merged_by")), "mesclado_em": mr.get("merged_at"),
+                          "sha_merge": mr.get("merge_commit_sha")}
+
+
 def main() -> None:
     mcp.run()
 

{mcp_gitlabpr-1.0.0 → mcp_gitlabpr-1.0.2}/pyproject.toml

@@ -1,7 +1,7 @@
 [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"
+version = "1.0.2"
+description = "MCP server para merge requests do GitLab (API v4, CE 10.8+): listar, obter, criar e mesclar, só no projeto do workspace"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -13,7 +13,7 @@ dependencies = [
 ]
 
 [project.urls]
-Repository = "https://github.com/dxaraujo/kiro/tree/main/mcps/gitlabpr"
+Repository = "https://github.com/dxaraujo/mcp-gitlabpr"
 
 [project.scripts]
 mcp-gitlabpr = "mcp_gitlabpr.server:main"

{mcp_gitlabpr-1.0.0 → mcp_gitlabpr-1.0.2}/tests/test_server.py

@@ -35,8 +35,17 @@ class FakeAdapter(BaseAdapter):
         pass
 
 
+def git(*args):
+    subprocess.run(["git", *args], check=True, capture_output=True)
+
+
 @pytest.fixture
-def fake():
+def fake(tmp_path_factory, monkeypatch):
+    """Sessão falsa, rodando num repositório git cujo origin é o projeto g/p do GitLab de teste."""
+    repo = tmp_path_factory.mktemp("repo")
+    monkeypatch.chdir(repo)
+    git("init", "-q", "-b", "feat")
+    git("remote", "add", "origin", "git@gitlab.test:g/p.git")
     adapter = FakeAdapter()
     session = server.GitlabSession(GitlabConfig(url="https://gitlab.test", token="tok"))
     session.session.mount("https://", adapter)
@@ -59,7 +68,7 @@ def test_config(tmp_path):
 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)
+    out = server.gitlab_listar_mrs(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
@@ -67,40 +76,59 @@ def test_listar_projeto(fake):
     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
+def test_listar_estado_invalido(fake):
     with pytest.raises(ValueError):
-        server.gitlab_listar_mrs("g/p", estado="aberto")
+        server.gitlab_listar_mrs(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)
+    fake.routes[("GET", f"{API}/projects/g%2Fp/merge_requests/7/changes")] = (200, MR | {"changes": [change]})
+    out = server.gitlab_obter_mr(7, 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"])
+    out = server.gitlab_criar_mr("Ajuste", "dev", origem="feat", 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"}
+                                               "remove_source_branch": True, "assignee_id": 9, "labels": "a,b"}
     assert out["iid"] == 7
+    server.gitlab_criar_mr("Ajuste", "dev", origem="feat", remover_origem=False)  # quem quiser manter a branch
+    assert json.loads(fake.calls[-1].body)["remove_source_branch"] is False
 
 
 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")
+        server.gitlab_criar_mr("t", "dev", origem="feat", 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")
+        server.gitlab_criar_mr("t", "dev", origem="feat")
     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")
+        server.gitlab_obter_mr(1)
+
+
+def test_mesclar(fake):
+    base = f"{API}/projects/g%2Fp/merge_requests/7"
+    fake.routes[("GET", base)] = (200, MR | {"merge_status": "can_be_merged"})
+    fake.routes[("PUT", base + "/merge")] = (200, MR | {"state": "merged", "merged_by": {"username": "ana"},
+                                                        "merge_commit_sha": "abc"})
+    out = server.gitlab_mesclar_mr(7, sha="f00", remover_origem=True)
+    assert json.loads(fake.calls[-1].body) == {"sha": "f00", "should_remove_source_branch": True}
+    assert out["estado"] == "merged" and out["mesclado_por"] == "ana" and out["sha_merge"] == "abc"
+
+
+@pytest.mark.parametrize("extra, erro", [({"state": "merged"}, "aberto"), ({"work_in_progress": True}, "WIP"),
+                                         ({"has_conflicts": True}, "conflito"),
+                                         ({"merge_status": "cannot_be_merged"}, "conflito")])
+def test_mesclar_recusa(fake, extra, erro):
+    fake.routes[("GET", f"{API}/projects/g%2Fp/merge_requests/7")] = (200, MR | extra)
+    with pytest.raises(ValueError, match=erro):
+        server.gitlab_mesclar_mr(7)
+    assert not any(c.method == "PUT" for c in fake.calls)
 
 
 @pytest.mark.parametrize("url", ["https://gitlab.test/g/sub/p.git", "git@gitlab.test:g/sub/p.git",
@@ -114,13 +142,16 @@ def test_caminho_remoto_subcaminho(fake):
     assert server._caminho_remoto("https://host/gitlab/g/p.git") == "g/p"
 
 
-def git(*args):
-    subprocess.run(["git", *args], check=True, capture_output=True)
+@pytest.mark.parametrize("url", ["https://github.com/g/p.git", "git@github.com:g/p.git",
+                                 "ssh://git@github.com/g/p.git"])
+def test_remote_de_outro_host(fake, url):
+    with pytest.raises(ValueError, match="não é do GitLab configurado"):
+        server._caminho_remoto(url)
 
 
 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"):
+    with pytest.raises(ValueError, match="raiz do workspace"):
         server.gitlab_listar_mrs()
     with pytest.raises(ValueError, match="pergunte ao usuário a branch"):
         server.gitlab_criar_mr("t", "dev")
@@ -130,3 +161,36 @@ def test_projeto_e_branch_do_git(fake, tmp_path, monkeypatch):
     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"
+
+
+def test_pasta_do_workspace(fake, tmp_path, monkeypatch):
+    """Com `pasta`, o projeto vem do repositório dela, não do cwd (o Kiro não inicia o MCP de um power no workspace)."""
+    repo = tmp_path / "ws"
+    repo.mkdir()
+    monkeypatch.chdir(repo)
+    git("init", "-q", "-b", "feat")
+    git("remote", "add", "origin", "https://gitlab.test/outro/ws.git")
+    monkeypatch.chdir(tmp_path)
+    fake.routes[("GET", f"{API}/projects/outro%2Fws/merge_requests")] = (200, [])
+    server.gitlab_listar_mrs(pasta=str(repo))
+    assert "/projects/outro%2Fws/" in fake.calls[-1].url
+    with pytest.raises(ValueError, match="não existe"):
+        server.gitlab_listar_mrs(pasta=str(tmp_path / "nada"))
+
+
+@pytest.mark.parametrize("url", ["https://gitlab.test/g/p", "https://gitlab.test/g/p/", "https://gitlab.test/g/p.git",
+                                 "https://gitlab.test/g/p/merge_requests/7", "https://gitlab.test/g/p/-/tree/dev"])
+def test_url_projeto_colada(fake, tmp_path, monkeypatch, url):
+    """Fora de um repositório, a pessoa cola a URL do projeto; vale a de um MR ou de outra página dele."""
+    monkeypatch.chdir(tmp_path)
+    fake.routes[("GET", f"{API}/projects/g%2Fp/merge_requests")] = (200, [])
+    server.gitlab_listar_mrs(url_projeto=url)
+    assert "/projects/g%2Fp/merge_requests" in fake.calls[-1].url
+
+
+def test_url_projeto_recusada(fake):
+    for url in ("https://github.com/g/p", "g/p", "123"):
+        with pytest.raises(ValueError):
+            server.gitlab_listar_mrs(url_projeto=url)
+    with pytest.raises(ValueError, match="branch de origem"):
+        server.gitlab_criar_mr("t", "dev", url_projeto="https://gitlab.test/g/p")

mcp_gitlabpr-1.0.0/PKG-INFO

@@ -1,79 +0,0 @@
-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

@@ -1,66 +0,0 @@
-# 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`.