patlab-mcp 0.1.1__tar.gz

patlab_mcp-0.1.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: patlab-mcp
+Version: 0.1.1
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.9
+Requires-Dist: httpx>=0.28
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.9; extra == "dev"
+Requires-Dist: ty>=0.0.1a0; extra == "dev"

patlab_mcp-0.1.1/patlab_mcp/client.py

@@ -0,0 +1,55 @@
+import os
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+_DEFAULT_API_URL = "https://gitlab.com/api/v4"
+
+_cache: dict[tuple[str, str], Any] = {}
+
+
+def validate_env() -> None:
+    if not os.environ.get("GITLAB_TOKEN"):
+        raise RuntimeError("Missing required environment variable: GITLAB_TOKEN")
+
+
+def validate_gitlab_args(
+    project_id: str | None,
+    mr_iid: int | None,
+) -> tuple[str, str]:
+    """
+    Resolve project_id and mr_iid from explicit args or env vars. Returns (project_id, mr_iid) as strings.
+    """
+    resolved_project = project_id or os.environ.get("CI_PROJECT_ID")
+    resolved_iid = str(mr_iid) if mr_iid is not None else os.environ.get("CI_MERGE_REQUEST_IID")
+    if not resolved_project:
+        raise ValueError("Missing project_id: pass explicitly or set CI_PROJECT_ID")
+    if not resolved_iid:
+        raise ValueError("Missing mr_iid: pass explicitly or set CI_MERGE_REQUEST_IID")
+    return resolved_project, resolved_iid
+
+
+def make_client() -> httpx.AsyncClient:
+    token = os.environ["GITLAB_TOKEN"]
+    base_url = os.environ.get("CI_API_V4_URL", _DEFAULT_API_URL).rstrip("/")
+    return httpx.AsyncClient(
+        base_url=base_url,
+        headers={"PRIVATE-TOKEN": token},
+        timeout=30.0,
+    )
+
+
+def mr_base_url(project_id: str, mr_iid: str) -> str:
+    return f"/projects/{quote(project_id, safe='')}/merge_requests/{mr_iid}"
+
+
+async def get_cached_mr(project_id: str, mr_iid: str, force_origin_read: bool = False) -> dict[str, Any]:
+    """Fetch and cache the MR payload. Pass force=True to overwrite the cache (e.g. after an MR update)."""
+    key = (project_id, mr_iid)
+    if force_origin_read or key not in _cache:
+        async with make_client() as client:
+            r = await client.get(mr_base_url(project_id, mr_iid))
+            r.raise_for_status()
+            _cache[key] = r.json()
+    return _cache[key]

patlab_mcp-0.1.1/patlab_mcp/server.py

@@ -0,0 +1,34 @@
+import logging
+import os
+import sys
+
+from mcp.server.fastmcp import FastMCP
+
+from patlab_mcp.client import validate_env
+from patlab_mcp.tools import read, write
+
+_DURABLE_SUFFIX = (
+    "\n\nDurable session: CI env vars not set. Always pass project_id and mr_iid explicitly - "
+    "infer from the GitLab URL or user-provided context."
+)
+
+mcp = FastMCP("patlab")
+_durable = os.environ.get("PATLAB_DURABLE", "").lower() not in ("", "0", "false", "no")
+
+for tool in [*read.TOOLS, *write.TOOLS]:
+    desc = (tool.__doc__ or "") + _DURABLE_SUFFIX if _durable else tool.__doc__
+    mcp.tool(description=desc)(tool)
+
+
+def main() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        stream=sys.stderr,
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    validate_env()  # only checks GITLAB_TOKEN
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

patlab_mcp-0.1.1/patlab_mcp/tools/helpers.py

@@ -0,0 +1,61 @@
+import hashlib
+from pathlib import Path
+from typing import Any
+
+# Written on unrecoverable auth failures so the caller can exit 1 after the MCP session finishes.
+_SENTINEL = Path("/tmp/patlab-fatal")  # nosemgrep
+
+
+def fatal(message: str) -> None:
+    _SENTINEL.write_text(message)
+
+
+def line_code(old_path: str, new_path: str, old_line: int, new_line: int) -> str:
+    # Yes, we're using SHA1. Yes, we have to to match Git's behavior.
+    sha = hashlib.sha1(f"{old_path}{new_path}".encode()).hexdigest()
+    return f"{sha}_{old_line}_{new_line}"
+
+
+def line_ref_added(old_path: str, new_path: str, new_line: int) -> dict[str, Any]:
+    """Build a line_range start/end object for an added line (old_line=0, type='new')."""
+    return {
+        "line_code": line_code(old_path, new_path, 0, new_line),
+        "type": "new",
+        "old_line": 0,
+        "new_line": new_line,
+    }
+
+
+def suggestion_fence(suggested_code: str, new_line: int, new_line_end: int | None) -> str:
+    if new_line_end is not None and new_line_end < new_line:
+        raise ValueError(f"new_line_end ({new_line_end}) must be >= new_line ({new_line})")
+    offset = 0 if new_line_end is None else new_line_end - new_line
+    if not suggested_code.endswith("\n"):
+        suggested_code += "\n"
+    return f"```suggestion:-0+{offset}\n{suggested_code}```"
+
+
+def truncate_body(body: str, head: int = 60, tail: int = 20) -> str:
+    if len(body) <= head + tail:
+        return repr(body)
+    return f"{body[:head]!r}...{body[-tail:]!r}"
+
+
+def build_position(
+    diff_refs: dict, new_path: str, old_path: str, new_line: int, new_line_end: int | None
+) -> dict[str, Any]:
+    position: dict[str, Any] = {
+        "position_type": "text",
+        "base_sha": diff_refs["base_sha"],
+        "head_sha": diff_refs["head_sha"],
+        "start_sha": diff_refs["start_sha"],
+        "new_path": new_path,
+        "old_path": old_path,
+        "new_line": new_line,
+    }
+    if new_line_end is not None:
+        position["line_range"] = {
+            "start": line_ref_added(old_path, new_path, new_line),
+            "end": line_ref_added(old_path, new_path, new_line_end),
+        }
+    return position

patlab_mcp-0.1.1/patlab_mcp/tools/read.py

@@ -0,0 +1,157 @@
+import logging
+from typing import Any
+
+from patlab_mcp.client import get_cached_mr, make_client, mr_base_url, validate_gitlab_args
+
+log = logging.getLogger(__name__)
+
+
+async def get_mr_info(
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> dict[str, Any]:
+    """
+    Fetch metadata for the current MR: title, description, author, source/target
+    branches, state, labels, milestone, and the diff_refs block (base_sha, head_sha,
+    start_sha) required for posting inline comments.
+
+    Always fetches fresh from the API (bypasses cache) - MR metadata may change between
+    calls in a durable session (e.g. new commits, label changes).
+
+    Arguments:
+      project_id - numeric ID or namespace/repo slug (e.g. "mygroup/myrepo").
+                   Defaults to CI_PROJECT_ID env var.
+      mr_iid     - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(f"get_mr_info project={pid} mr={iid}")
+    mr = await get_cached_mr(pid, iid, force_origin_read=True)
+    log.info(f"get_mr_info -> iid={mr['iid']} title={mr['title']!r} state={mr['state']}")
+
+    return {
+        "iid": mr["iid"],
+        "title": mr["title"],
+        "description": mr.get("description") or "",
+        "state": mr["state"],
+        "author": mr["author"]["username"],
+        "source_branch": mr["source_branch"],
+        "target_branch": mr["target_branch"],
+        "labels": mr.get("labels", []),
+        "milestone": mr["milestone"]["title"] if mr.get("milestone") else None,
+        "diff_refs": mr["diff_refs"],
+        "web_url": mr["web_url"],
+    }
+
+
+async def get_mr_diff(
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> list[dict[str, Any]]:
+    """
+    Fetch the file diffs for the current MR as raw unified diffs. Use this only
+    when `git diff` is unavailable (e.g. GIT_STRATEGY: none).
+
+    Arguments:
+      project_id - numeric ID or namespace/repo slug. Defaults to CI_PROJECT_ID env var.
+      mr_iid     - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+
+    Returns a list of file objects, each with:
+      - old_path / new_path
+      - new_file / deleted_file / renamed_file: bool flags
+      - diff: the raw unified diff string
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(f"get_mr_diff project={pid} mr={iid}")
+    base = mr_base_url(pid, iid)
+    async with make_client() as client:
+        raw_diffs: list[dict] = []
+        page = 1
+        while True:
+            r = await client.get(
+                base + "/diffs",
+                params={"per_page": 100, "page": page},
+            )
+            r.raise_for_status()
+            batch = r.json()
+            if not batch:
+                break
+            raw_diffs.extend(batch)
+            page += 1
+
+    log.info(f"get_mr_diff -> {len(raw_diffs)} files")
+    return [
+        {
+            "old_path": f["old_path"],
+            "new_path": f["new_path"],
+            "new_file": f.get("new_file", False),
+            "deleted_file": f.get("deleted_file", False),
+            "renamed_file": f.get("renamed_file", False),
+            "diff": f.get("diff", ""),
+        }
+        for f in raw_diffs
+    ]
+
+
+async def list_discussions(
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> list[dict[str, Any]]:
+    """
+    List all discussions (comment threads) on the current MR. Read these before
+    posting anything to avoid duplication and to understand what other reviewers
+    have raised.
+
+    Arguments:
+      project_id - numeric ID or namespace/repo slug. Defaults to CI_PROJECT_ID env var.
+      mr_iid     - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+
+    Returns a list of discussion objects, each with:
+      - id: discussion ID (pass to reply_to_discussion)
+      - resolved: bool
+      - notes: list of individual comments, each with:
+          - id: note ID (pass to react_to_comment)
+          - author, body, created_at
+          - position: inline position if applicable (may be null)
+          - resolvable / resolved
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(f"list_discussions project={pid} mr={iid}")
+    base = mr_base_url(pid, iid)
+    async with make_client() as client:
+        discussions: list[dict] = []
+        page = 1
+        while True:
+            r = await client.get(
+                base + "/discussions",
+                params={"per_page": 100, "page": page},
+            )
+            r.raise_for_status()
+            batch = r.json()
+            if not batch:
+                break
+            discussions.extend(batch)
+            page += 1
+
+    log.info(f"list_discussions -> {len(discussions)} discussions")
+    return [
+        {
+            "id": d["id"],
+            "resolved": d.get("resolved", False),
+            "notes": [
+                {
+                    "id": n["id"],
+                    "author": n["author"]["username"],
+                    "body": n["body"],
+                    "created_at": n["created_at"],
+                    "resolvable": n.get("resolvable", False),
+                    "resolved": n.get("resolved", False),
+                    "position": n.get("position"),
+                }
+                for n in d.get("notes", [])
+            ],
+        }
+        for d in discussions
+    ]
+
+
+TOOLS = [get_mr_info, get_mr_diff, list_discussions]

patlab_mcp-0.1.1/patlab_mcp/tools/write.py

@@ -0,0 +1,184 @@
+import logging
+from typing import Any, Literal
+
+from patlab_mcp.client import get_cached_mr, make_client, mr_base_url, validate_gitlab_args
+from patlab_mcp.tools.helpers import build_position, fatal, suggestion_fence, truncate_body
+
+log = logging.getLogger(__name__)
+
+Emoji = Literal[
+    "thumbsup",  # 👍  valid concern worth acknowledging
+    "thumbsdown",  # 👎
+    "joy",  # 😂  genuinely funny comment
+    "skull",  # 💀  same
+    "tada",  # 🎉  excellent suggestion
+    "raised_hands",  # 🙌  same
+    "fire",  # 🔥  same
+]
+
+
+async def post_inline_comment(
+    new_path: str,
+    new_line: int,
+    body: str,
+    old_path: str | None = None,
+    new_line_end: int | None = None,
+    suggestion: str | None = None,
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> dict[str, Any]:
+    """
+    Post an inline comment on a specific line (or line range) of a changed file in the MR diff.
+
+    Arguments:
+      new_path     - file path in the new version (as shown in the diff header)
+      new_line     - line number in the new file version to anchor the comment on.
+                     For a range, this is the first line. Must be an added line (shown
+                     as green in the diff). Context and removed lines are not supported.
+      body         - markdown comment body. Must not contain suggestion syntax - use the
+                     `suggestion` argument instead. May be empty string if suggestion is provided.
+      old_path     - only needed for renamed files; defaults to new_path.
+      new_line_end - last line of the range for a multi-line comment. When provided,
+                     the comment spans new_line..new_line_end (inclusive). Required when
+                     `suggestion` replaces more than one line. Omit for single-line comments.
+      suggestion   - proposed replacement code for the selected line(s). When provided, the
+                     tool wraps it in a GitLab suggestion fence with the correct offset computed
+                     from new_line and new_line_end - do NOT write suggestion syntax in `body`.
+      project_id   - numeric ID or namespace/repo slug. Defaults to CI_PROJECT_ID env var.
+      mr_iid       - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+
+    Returns the created discussion_id and note_id.
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(
+        f"post_inline_comment project={pid} mr={iid} path={new_path} line={new_line}"
+        + (f"-{new_line_end}" if new_line_end else "")
+        + f" body={truncate_body(body)}"
+    )
+    mr = await get_cached_mr(pid, iid)
+    resolved_old_path = old_path or new_path
+
+    if suggestion is not None:
+        fence = suggestion_fence(suggestion, new_line, new_line_end)
+        full_body = f"{fence}\n\n{body}" if body else fence
+    else:
+        full_body = body
+
+    payload = {
+        "body": full_body,
+        "position": build_position(mr["diff_refs"], new_path, resolved_old_path, new_line, new_line_end),
+    }
+
+    async with make_client() as client:
+        r = await client.post(mr_base_url(pid, iid) + "/discussions", json=payload)
+        if r.status_code in (401, 403):
+            fatal(f"post_inline_comment: HTTP {r.status_code} - token lacks permission to post comments")
+        r.raise_for_status()
+        discussion = r.json()
+
+    result = {"discussion_id": discussion["id"], "note_id": discussion["notes"][0]["id"]}
+    log.info(f"post_inline_comment -> {result}")
+    return result
+
+
+async def post_summary_comment(
+    body: str,
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> dict[str, Any]:
+    """
+    Post a single MR-level summary comment. Call this once at the end of the review
+    to summarise the changeset as a whole - alignment with the MR description, any
+    cross-cutting observations, and overall assessment.
+
+    Arguments:
+      project_id - numeric ID or namespace/repo slug. Defaults to CI_PROJECT_ID env var.
+      mr_iid     - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+
+    Returns the created note_id.
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(f"post_summary_comment project={pid} mr={iid} body={truncate_body(body)}")
+    async with make_client() as client:
+        r = await client.post(mr_base_url(pid, iid) + "/notes", json={"body": body})
+        if r.status_code in (401, 403):
+            fatal(f"post_summary_comment: HTTP {r.status_code} - token lacks permission to post comments")
+        r.raise_for_status()
+
+    result = {"note_id": r.json()["id"]}
+    log.info(f"post_summary_comment -> {result}")
+    return result
+
+
+async def reply_to_discussion(
+    discussion_id: str,
+    body: str,
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> dict[str, Any]:
+    """
+    Reply to an existing discussion thread. Use this to build on another reviewer's
+    comment - e.g. to provide a concrete implementation of a suggested change.
+    Do not use it to contradict other reviewers without clear technical grounds.
+    Avoid replying to threads that are already resolved or headed toward resolution.
+
+    Arguments:
+      discussion_id - the discussion ID returned by list_discussions.
+      project_id    - numeric ID or namespace/repo slug. Defaults to CI_PROJECT_ID env var.
+      mr_iid        - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+
+    Returns the created note_id.
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(
+        f"reply_to_discussion project={pid} mr={iid} discussion={discussion_id} body={truncate_body(body)}"
+    )
+    async with make_client() as client:
+        r = await client.post(
+            mr_base_url(pid, iid) + f"/discussions/{discussion_id}/notes",
+            json={"body": body},
+        )
+        if r.status_code in (401, 403):
+            fatal(f"reply_to_discussion: HTTP {r.status_code} - token lacks permission to post comments")
+        r.raise_for_status()
+
+    result = {"note_id": r.json()["id"]}
+    log.info(f"reply_to_discussion -> {result}")
+    return result
+
+
+async def react_to_comment(
+    note_id: int,
+    emoji: Emoji,
+    project_id: str | None = None,
+    mr_iid: int | None = None,
+) -> dict[str, Any]:
+    """
+    Add an emoji reaction to an existing MR note. Use sparingly - only when a
+    simple acknowledgement genuinely adds value. Do not react to every comment.
+
+    Arguments:
+      note_id    - the note ID returned by list_discussions.
+      emoji      - one of the allowed emoji shortcode names (see type annotation).
+      project_id - numeric ID or namespace/repo slug. Defaults to CI_PROJECT_ID env var.
+      mr_iid     - MR internal ID. Defaults to CI_MERGE_REQUEST_IID env var.
+
+    Returns the created award ID.
+    """
+    pid, iid = validate_gitlab_args(project_id, mr_iid)
+    log.info(f"react_to_comment project={pid} mr={iid} note={note_id} emoji={emoji}")
+    async with make_client() as client:
+        r = await client.post(
+            mr_base_url(pid, iid) + f"/notes/{note_id}/award_emoji",
+            json={"name": emoji},
+        )
+        if r.status_code in (401, 403):
+            fatal(f"react_to_comment: HTTP {r.status_code} - token lacks permission to react to comments")
+        r.raise_for_status()
+
+    result = {"award_id": r.json()["id"]}
+    log.info(f"react_to_comment -> {result}")
+    return result
+
+
+TOOLS = [post_inline_comment, post_summary_comment, reply_to_discussion, react_to_comment]

patlab_mcp-0.1.1/patlab_mcp.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: patlab-mcp
+Version: 0.1.1
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.9
+Requires-Dist: httpx>=0.28
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Requires-Dist: ruff>=0.9; extra == "dev"
+Requires-Dist: ty>=0.0.1a0; extra == "dev"

patlab_mcp-0.1.1/patlab_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+pyproject.toml
+patlab_mcp/__init__.py
+patlab_mcp/client.py
+patlab_mcp/server.py
+patlab_mcp.egg-info/PKG-INFO
+patlab_mcp.egg-info/SOURCES.txt
+patlab_mcp.egg-info/dependency_links.txt
+patlab_mcp.egg-info/entry_points.txt
+patlab_mcp.egg-info/requires.txt
+patlab_mcp.egg-info/top_level.txt
+patlab_mcp/tools/__init__.py
+patlab_mcp/tools/helpers.py
+patlab_mcp/tools/read.py
+patlab_mcp/tools/write.py
+tests/test_read.py
+tests/test_write.py

patlab_mcp-0.1.1/patlab_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

patlab_mcp-0.1.1/patlab_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+patlab-mcp = patlab_mcp.server:main

patlab_mcp-0.1.1/patlab_mcp.egg-info/requires.txt

@@ -0,0 +1,10 @@
+mcp>=1.9
+httpx>=0.28
+
+[dev]
+pytest>=8
+pytest-asyncio>=0.24
+pytest-cov>=5
+respx>=0.21
+ruff>=0.9
+ty>=0.0.1a0

patlab_mcp-0.1.1/patlab_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+patlab_mcp

patlab_mcp-0.1.1/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "patlab-mcp"
+version = "0.1.1"
+requires-python = ">=3.11"
+dependencies = [
+    "mcp>=1.9",
+    "httpx>=0.28",
+]
+
+[project.scripts]
+patlab-mcp = "patlab_mcp.server:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["patlab_mcp*"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "--cov=patlab_mcp --cov-report=term-missing"
+
+[tool.coverage.run]
+source = ["patlab_mcp"]
+
+[tool.ruff]
+line-length = 110
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.ty.environment]
+python-version = "3.11"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "pytest-cov>=5",
+    "respx>=0.21",
+    "ruff>=0.9",
+    "ty>=0.0.1a0",
+]

patlab_mcp-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

patlab_mcp-0.1.1/tests/test_read.py

@@ -0,0 +1,179 @@
+import respx
+from httpx import Response
+
+from patlab_mcp.tools.read import get_mr_diff, get_mr_info, list_discussions
+from tests.conftest import API_URL, MR_IID, MR_PAYLOAD, MR_URL, PROJECT_ID
+
+
+@respx.mock
+async def test_get_mr_info_returns_expected_fields():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+
+    result = await get_mr_info(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert result["iid"] == 42
+    assert result["title"] == "Add feature X"
+    assert result["author"] == "dev"
+    assert result["diff_refs"] == MR_PAYLOAD["diff_refs"]
+    assert result["source_branch"] == "feature/x"
+    assert result["target_branch"] == "main"
+
+
+@respx.mock
+async def test_get_mr_info_slug_is_url_encoded():
+    slug = "mygroup/myrepo"
+    encoded_url = f"{API_URL}/projects/mygroup%2Fmyrepo/merge_requests/{MR_IID}"
+    respx.get(encoded_url).mock(return_value=Response(200, json=MR_PAYLOAD))
+
+    result = await get_mr_info(project_id=slug, mr_iid=int(MR_IID))
+
+    assert result["iid"] == 42
+
+
+@respx.mock
+async def test_get_mr_info_always_refreshes_cache():
+    route = respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+
+    await get_mr_info(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+    await get_mr_info(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert route.call_count == 2
+
+
+@respx.mock
+async def test_get_mr_info_none_description_becomes_empty_string():
+    payload = {**MR_PAYLOAD, "description": None}
+    respx.get(MR_URL).mock(return_value=Response(200, json=payload))
+
+    result = await get_mr_info(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert result["description"] == ""
+
+
+@respx.mock
+async def test_get_mr_info_milestone_title_extracted():
+    payload = {**MR_PAYLOAD, "milestone": {"title": "v2.0"}}
+    respx.get(MR_URL).mock(return_value=Response(200, json=payload))
+
+    result = await get_mr_info(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert result["milestone"] == "v2.0"
+
+
+@respx.mock
+async def test_get_mr_diff_returns_file_list():
+    diffs = [
+        {
+            "old_path": "foo.py",
+            "new_path": "foo.py",
+            "new_file": False,
+            "deleted_file": False,
+            "renamed_file": False,
+            "diff": "@@ -1,2 +1,3 @@\n def foo():\n-    pass\n+    return 1\n",
+        }
+    ]
+    respx.get(f"{MR_URL}/diffs", params={"per_page": 100, "page": 1}).mock(
+        return_value=Response(200, json=diffs)
+    )
+    respx.get(f"{MR_URL}/diffs", params={"per_page": 100, "page": 2}).mock(
+        return_value=Response(200, json=[])
+    )
+
+    result = await get_mr_diff(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert len(result) == 1
+    assert result[0]["new_path"] == "foo.py"
+    assert "@@ -1,2 +1,3 @@" in result[0]["diff"]
+
+
+@respx.mock
+async def test_get_mr_diff_paginates_until_empty():
+    def make_diff(path: str) -> dict:
+        return {
+            "old_path": path,
+            "new_path": path,
+            "new_file": False,
+            "deleted_file": False,
+            "renamed_file": False,
+            "diff": f"@@ -1 +1 @@\n {path}\n",
+        }
+
+    respx.get(f"{MR_URL}/diffs", params={"per_page": 100, "page": 1}).mock(
+        return_value=Response(200, json=[make_diff("a.py"), make_diff("b.py")])
+    )
+    respx.get(f"{MR_URL}/diffs", params={"per_page": 100, "page": 2}).mock(
+        return_value=Response(200, json=[make_diff("c.py")])
+    )
+    respx.get(f"{MR_URL}/diffs", params={"per_page": 100, "page": 3}).mock(
+        return_value=Response(200, json=[])
+    )
+
+    result = await get_mr_diff(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert len(result) == 3
+    assert [f["new_path"] for f in result] == ["a.py", "b.py", "c.py"]
+
+
+@respx.mock
+async def test_list_discussions_paginates_until_empty():
+    page1 = [
+        {
+            "id": "abc",
+            "resolved": False,
+            "notes": [
+                {
+                    "id": 1,
+                    "author": {"username": "alice"},
+                    "body": "looks good",
+                    "created_at": "2024-01-01",
+                    "resolvable": False,
+                    "resolved": False,
+                    "position": None,
+                },
+            ],
+        },
+    ]
+    respx.get(f"{MR_URL}/discussions", params={"per_page": 100, "page": 1}).mock(
+        return_value=Response(200, json=page1)
+    )
+    respx.get(f"{MR_URL}/discussions", params={"per_page": 100, "page": 2}).mock(
+        return_value=Response(200, json=[])
+    )
+
+    result = await list_discussions(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert len(result) == 1
+    assert result[0]["id"] == "abc"
+    assert result[0]["notes"][0]["author"] == "alice"
+
+
+@respx.mock
+async def test_list_discussions_exposes_position_for_inline_notes():
+    position = {"new_path": "foo.py", "new_line": 5}
+    page1 = [
+        {
+            "id": "xyz",
+            "resolved": False,
+            "notes": [
+                {
+                    "id": 2,
+                    "author": {"username": "bob"},
+                    "body": "why?",
+                    "created_at": "2024-01-02",
+                    "resolvable": True,
+                    "resolved": False,
+                    "position": position,
+                },
+            ],
+        },
+    ]
+    respx.get(f"{MR_URL}/discussions", params={"per_page": 100, "page": 1}).mock(
+        return_value=Response(200, json=page1)
+    )
+    respx.get(f"{MR_URL}/discussions", params={"per_page": 100, "page": 2}).mock(
+        return_value=Response(200, json=[])
+    )
+
+    result = await list_discussions(project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert result[0]["notes"][0]["position"] == position

patlab_mcp-0.1.1/tests/test_write.py

@@ -0,0 +1,316 @@
+import hashlib
+import json
+
+import httpx
+import pytest
+import respx
+from httpx import Response
+
+from patlab_mcp.tools.helpers import suggestion_fence, truncate_body
+from patlab_mcp.tools.write import (
+    post_inline_comment,
+    post_summary_comment,
+    react_to_comment,
+    reply_to_discussion,
+)
+from tests.conftest import MR_IID, MR_PAYLOAD, MR_URL, PROJECT_ID
+
+
+def test_suggestion_fence_single_line():
+    assert suggestion_fence("fixed()\n", 5, None) == "```suggestion:-0+0\nfixed()\n```"
+
+
+def test_suggestion_fence_multi_line():
+    assert suggestion_fence("a\nb\n", 3, 5) == "```suggestion:-0+2\na\nb\n```"
+
+
+def test_suggestion_fence_normalizes_missing_trailing_newline():
+    assert suggestion_fence("fixed()", 5, None) == "```suggestion:-0+0\nfixed()\n```"
+
+
+def test_suggestion_fence_raises_on_inverted_range():
+    with pytest.raises(ValueError, match="new_line_end"):
+        suggestion_fence("x\n", new_line=10, new_line_end=5)
+
+
+def test_truncate_body_short():
+    assert truncate_body("hello") == "'hello'"
+
+
+def test_truncate_body_long():
+    body = "a" * 61 + "b" * 20
+    result = truncate_body(body)
+    assert result.startswith("'aaa")
+    assert "..." in result
+    assert result.endswith("bbbb'")
+
+
+@respx.mock
+async def test_post_inline_comment_suggestion_builds_body():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-s1", "notes": [{"id": 20}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="foo.py",
+        new_line=5,
+        body="nit: prefer this",
+        suggestion="return x + 1\n",
+        project_id=PROJECT_ID,
+        mr_iid=int(MR_IID),
+    )
+
+    body = json.loads(route.calls[0].request.content)["body"]
+    assert body.startswith("```suggestion:-0+0\n")
+    assert "return x + 1" in body
+    assert "nit: prefer this" in body
+
+
+@respx.mock
+async def test_post_inline_comment_suggestion_no_prose():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-s2", "notes": [{"id": 21}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="foo.py",
+        new_line=5,
+        body="",
+        suggestion="return x + 1\n",
+        project_id=PROJECT_ID,
+        mr_iid=int(MR_IID),
+    )
+
+    body = json.loads(route.calls[0].request.content)["body"]
+    assert body == "```suggestion:-0+0\nreturn x + 1\n```"
+
+
+@respx.mock
+async def test_post_inline_comment_uses_diff_refs():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-1", "notes": [{"id": 10}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    result = await post_inline_comment(
+        new_path="foo.py", new_line=5, body="fix this", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+    )
+
+    assert result == {"discussion_id": "disc-1", "note_id": 10}
+    payload = route.calls[0].request
+
+    body = json.loads(payload.content)
+    assert body["position"]["base_sha"] == "aaaa"
+    assert body["position"]["head_sha"] == "bbbb"
+    assert body["position"]["start_sha"] == "cccc"
+    assert body["position"]["new_path"] == "foo.py"
+    assert body["position"]["new_line"] == 5
+
+
+@respx.mock
+async def test_post_inline_comment_old_path_defaults_to_new_path():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-2", "notes": [{"id": 11}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="bar.py", new_line=3, body="nit", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+    )
+
+    body = json.loads(route.calls[0].request.content)
+    assert body["position"]["old_path"] == "bar.py"
+
+
+@respx.mock
+async def test_post_inline_comment_renamed_file_uses_old_path():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-3", "notes": [{"id": 12}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="new.py",
+        new_line=1,
+        body="nit",
+        old_path="old.py",
+        project_id=PROJECT_ID,
+        mr_iid=int(MR_IID),
+    )
+
+    body = json.loads(route.calls[0].request.content)
+    assert body["position"]["old_path"] == "old.py"
+    assert body["position"]["new_path"] == "new.py"
+
+
+@respx.mock
+async def test_post_inline_comment_fetches_diff_refs_once_across_multiple_calls():
+    """Write tools use the cache (no force), so multiple inline comments only fetch the MR once."""
+    mr_route = respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-4", "notes": [{"id": 13}]}
+    respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="a.py", new_line=1, body="one", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+    )
+    await post_inline_comment(
+        new_path="b.py", new_line=2, body="two", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+    )
+
+    assert mr_route.call_count == 1
+
+
+@respx.mock
+async def test_post_inline_comment_single_line_has_no_line_range():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-5", "notes": [{"id": 14}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="foo.py", new_line=5, body="nit", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+    )
+
+    body = json.loads(route.calls[0].request.content)
+    assert "line_range" not in body["position"]
+
+
+@respx.mock
+async def test_post_inline_comment_range_sends_line_range():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-6", "notes": [{"id": 15}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="foo.py",
+        new_line=5,
+        body="fix this block",
+        new_line_end=9,
+        project_id=PROJECT_ID,
+        mr_iid=int(MR_IID),
+    )
+
+    body = json.loads(route.calls[0].request.content)
+    position = body["position"]
+    assert position["new_line"] == 5
+
+    lr = position["line_range"]
+    assert lr["start"]["new_line"] == 5
+    assert lr["start"]["old_line"] == 0
+    assert lr["start"]["type"] == "new"
+    assert lr["end"]["new_line"] == 9
+    assert lr["end"]["old_line"] == 0
+    assert lr["end"]["type"] == "new"
+
+    expected_sha = hashlib.sha1(b"foo.pyfoo.py").hexdigest()
+    assert lr["start"]["line_code"] == f"{expected_sha}_0_5"
+    assert lr["end"]["line_code"] == f"{expected_sha}_0_9"
+
+
+@respx.mock
+async def test_post_inline_comment_range_renamed_file_uses_old_path_in_line_code():
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    discussion = {"id": "disc-7", "notes": [{"id": 16}]}
+    route = respx.post(f"{MR_URL}/discussions").mock(return_value=Response(201, json=discussion))
+
+    await post_inline_comment(
+        new_path="new.py",
+        new_line=3,
+        body="fix range",
+        old_path="old.py",
+        new_line_end=6,
+        project_id=PROJECT_ID,
+        mr_iid=int(MR_IID),
+    )
+
+    body = json.loads(route.calls[0].request.content)
+    expected_sha = hashlib.sha1(b"old.pynew.py").hexdigest()
+    lr = body["position"]["line_range"]
+    assert lr["start"]["line_code"] == f"{expected_sha}_0_3"
+    assert lr["end"]["line_code"] == f"{expected_sha}_0_6"
+
+
+@respx.mock
+async def test_post_inline_comment_401_writes_sentinel(clean_sentinel):
+    respx.get(MR_URL).mock(return_value=Response(200, json=MR_PAYLOAD))
+    respx.post(f"{MR_URL}/discussions").mock(return_value=Response(401, json={}))
+
+    with pytest.raises(httpx.HTTPStatusError):
+        await post_inline_comment(
+            new_path="foo.py", new_line=1, body="x", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+        )
+
+    assert clean_sentinel.exists()
+    assert "401" in clean_sentinel.read_text()
+
+
+@respx.mock
+async def test_post_summary_comment_returns_note_id():
+    note = {"id": 99}
+    respx.post(f"{MR_URL}/notes").mock(return_value=Response(201, json=note))
+
+    result = await post_summary_comment("Overall LGTM", project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert result == {"note_id": 99}
+
+
+@respx.mock
+async def test_post_summary_comment_403_writes_sentinel(clean_sentinel):
+    respx.post(f"{MR_URL}/notes").mock(return_value=Response(403, json={}))
+
+    with pytest.raises(httpx.HTTPStatusError):
+        await post_summary_comment("summary", project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert clean_sentinel.exists()
+    assert "403" in clean_sentinel.read_text()
+
+
+@respx.mock
+async def test_reply_to_discussion_returns_note_id():
+    note = {"id": 55}
+    respx.post(f"{MR_URL}/discussions/disc-abc/notes").mock(return_value=Response(201, json=note))
+
+    result = await reply_to_discussion(
+        discussion_id="disc-abc", body="good catch, here's an impl", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+    )
+
+    assert result == {"note_id": 55}
+
+
+@respx.mock
+async def test_reply_to_discussion_401_writes_sentinel(clean_sentinel):
+    respx.post(f"{MR_URL}/discussions/disc-abc/notes").mock(return_value=Response(401, json={}))
+
+    with pytest.raises(httpx.HTTPStatusError):
+        await reply_to_discussion(
+            discussion_id="disc-abc", body="reply", project_id=PROJECT_ID, mr_iid=int(MR_IID)
+        )
+
+    assert clean_sentinel.exists()
+
+
+@respx.mock
+async def test_react_to_comment_returns_award_id():
+    award = {"id": 7}
+    respx.post(f"{MR_URL}/notes/42/award_emoji").mock(return_value=Response(201, json=award))
+
+    result = await react_to_comment(note_id=42, emoji="thumbsup", project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert result == {"award_id": 7}
+
+
+@respx.mock
+async def test_react_to_comment_sends_correct_emoji_name():
+    award = {"id": 8}
+    route = respx.post(f"{MR_URL}/notes/42/award_emoji").mock(return_value=Response(201, json=award))
+
+    await react_to_comment(note_id=42, emoji="tada", project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    body = json.loads(route.calls[0].request.content)
+    assert body["name"] == "tada"
+
+
+@respx.mock
+async def test_react_to_comment_403_writes_sentinel(clean_sentinel):
+    respx.post(f"{MR_URL}/notes/42/award_emoji").mock(return_value=Response(403, json={}))
+
+    with pytest.raises(httpx.HTTPStatusError):
+        await react_to_comment(note_id=42, emoji="fire", project_id=PROJECT_ID, mr_iid=int(MR_IID))
+
+    assert clean_sentinel.exists()