feat: automatically release status:in-progress on close and merge (#56)

mcp_server.py

@@ -743,6 +743,20 @@ def gitea_edit_pr(
     with _audited("edit_pr", host=h, remote=remote, org=o, repo=r,
                   pr_number=pr_number, request_metadata={"fields": sorted(payload)}):
         data = api_request("PATCH", url, auth, payload)
+
+    cleanup_status = None
+    if state == "closed":
+        cleanup = cleanup_in_progress_for_pr(data, remote, host, org, repo)
+        cleanup_status = cleanup.get("cleanup_status")
+        if isinstance(cleanup_status, dict):
+            for issue_num, st in cleanup_status.items():
+                if st == "released":
+                    try:
+                        comment_url = f"{repo_api_url(h, o, r)}/issues/{issue_num}/comments"
+                        api_request("POST", comment_url, auth, {"body": f"Tracker cleanup: removed `status:in-progress` from this issue because linked PR #{pr_number} was closed."})
+                    except Exception:
+                        pass
+
     return {
         "success": True,
         "number": data["number"],
@@ -750,6 +764,7 @@ def gitea_edit_pr(
         "body": data.get("body", ""),
         "state": data["state"],
         "url": data["html_url"],
+        "cleanup_status": cleanup_status,
     }
 
 
@@ -1021,6 +1036,9 @@ def gitea_merge_pr(
                 "GET", f"{repo_api_url(h, o, r)}/pulls/{pr_number}", auth
             )
             result["merge_commit"] = (merged or {}).get("merged_commit_sha")
+
+            cleanup = cleanup_in_progress_for_pr(merged or {}, remote, host, org, repo)
+            result["cleanup_status"] = cleanup.get("cleanup_status")
         except Exception:
             result["merge_commit"] = None
     except Exception as exc:  # noqa: BLE001 — redact before surfacing
@@ -1157,7 +1175,14 @@ def gitea_close_issue(
     with _audited("close_issue", host=h, remote=remote, org=o, repo=r,
                   issue_number=issue_number, request_metadata={"state": "closed"}):
         api_request("PATCH", url, auth, {"state": "closed"})
-    return {"success": True, "message": f"Issue #{issue_number} closed."}
+
+    cleanup_result = release_in_progress_label([issue_number], remote, host, org, repo)
+
+    return {
+        "success": True,
+        "message": f"Issue #{issue_number} closed.",
+        "cleanup_status": cleanup_result
+    }
 
 
 @mcp.tool()
@@ -1578,3 +1603,63 @@ def gitea_mirror_refs(
 
 if __name__ == "__main__":
     mcp.run(transport="stdio")
+import re
+
+def extract_linked_issue_numbers(text: str | None, branch_name: str | None = None) -> list[int]:
+    issues = set()
+    if text:
+        pattern = re.compile(r'(?i)(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?|ref[s]?)\s+#(\d+)')
+        issues.update(int(m) for m in pattern.findall(text))
+    if branch_name:
+        pattern = re.compile(r'(?i)issue-(\d+)')
+        issues.update(int(m) for m in pattern.findall(branch_name))
+    return sorted(list(issues))
+
+def release_in_progress_label(issue_numbers: list[int], remote: str, host: str | None, org: str | None, repo: str | None) -> dict:
+    if not issue_numbers:
+        return {}
+
+    h, o, r = _resolve(remote, host, org, repo)
+    auth = _auth(h)
+    base = repo_api_url(h, o, r)
+
+    try:
+        existing = api_request("GET", f"{base}/labels?limit=100", auth)
+        name_to_id = {lb["name"]: lb["id"] for lb in existing}
+    except Exception as exc:
+        return {num: f"error fetching repo labels: {_redact(str(exc))}" for num in issue_numbers}
+
+    results = {}
+    for num in issue_numbers:
+        try:
+            url = f"{base}/issues/{num}"
+            issue_data = api_request("GET", url, auth)
+            labels = [lb["name"] for lb in issue_data.get("labels", [])]
+
+            if "status:in-progress" in labels:
+                new_labels = [lb for lb in labels if lb != "status:in-progress"]
+                label_ids = [name_to_id[name] for name in new_labels if name in name_to_id]
+
+                with _audited("release_in_progress_label", host=h, remote=remote, org=o, repo=r, issue_number=num, request_metadata={"action": "remove status:in-progress"}):
+                    api_request("PUT", f"{url}/labels", auth, {"labels": label_ids})
+                results[num] = "released"
+            else:
+                results[num] = "not present"
+        except Exception as exc:
+            results[num] = f"error: {_redact(str(exc))}"
+
+    return results
+
+def cleanup_in_progress_for_pr(pr_payload: dict, remote: str, host: str | None, org: str | None, repo: str | None) -> dict:
+    body = pr_payload.get("body") or ""
+    title = pr_payload.get("title") or ""
+    branch = pr_payload.get("head", {}).get("ref") or ""
+
+    text = f"{title}\n{body}"
+    issues = extract_linked_issue_numbers(text, branch)
+
+    if not issues:
+        return {"cleanup_status": "no linked issue found"}
+
+    results = release_in_progress_label(issues, remote, host, org, repo)
+    return {"cleanup_status": results}

tests/test_mcp_server.py

@@ -93,7 +93,8 @@ class TestCloseIssue(unittest.TestCase):
         result = gitea_close_issue(issue_number=42)
         self.assertTrue(result["success"])
         self.assertIn("42", result["message"])
-        payload = mock_api.call_args[0][3]
+        patch_call = next(call for call in mock_api.call_args_list if call[0][0] == "PATCH")
+        payload = patch_call[0][3]
         self.assertEqual(payload["state"], "closed")
 
 
@@ -1352,3 +1353,211 @@ class TestSubmitPrReview(unittest.TestCase):
 
 if __name__ == "__main__":
     unittest.main()
+
+# ---------------------------------------------------------------------------
+# Tracker Hygiene Cleanup Tests
+# ---------------------------------------------------------------------------
+class TestTrackerHygieneCleanup(unittest.TestCase):
+
+    def setUp(self):
+        self.mock_api = patch("mcp_server.api_request").start()
+        self.mock_auth = patch("mcp_server.get_auth_header", return_value=FAKE_AUTH).start()
+        patch("gitea_audit.audit_enabled", return_value=True).start()
+        self.mock_audit = patch("gitea_audit.write_event").start()
+        patch("mcp_server.get_profile", return_value={"profile_name": "test", "allowed_operations": ["merge", "edit", "close"], "audit_label": "test", "forbidden_operations": []}).start()
+
+    def tearDown(self):
+        patch.stopall()
+
+    def test_close_issue_removes_in_progress(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "PATCH" and "issues/1" in url:
+                return {"state": "closed"}
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}, {"name": "bug", "id": 2}]
+            if method == "GET" and "issues/1" in url:
+                return {"labels": [{"name": "status:in-progress"}, {"name": "bug"}]}
+            if method == "PUT" and "labels" in url:
+                self.assertEqual(payload["labels"], [2])
+                return []
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_close_issue(issue_number=1)
+        self.assertTrue(res["success"])
+        self.assertEqual(res["cleanup_status"].get(1), "released")
+        self.mock_audit.assert_called()
+
+    def test_close_issue_no_label_is_noop(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "PATCH" and "issues/1" in url:
+                return {"state": "closed"}
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}, {"name": "bug", "id": 2}]
+            if method == "GET" and "issues/1" in url:
+                return {"labels": [{"name": "bug"}]}
+            if method == "PUT" and "labels" in url:
+                self.fail("Should not PUT labels")
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_close_issue(issue_number=1)
+        self.assertTrue(res["success"])
+        self.assertEqual(res["cleanup_status"].get(1), "not present")
+
+    def test_merge_pr_with_closes_removes_label(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "GET" and "/user" in url:
+                return {"login": "merger"}
+            if method == "GET" and "pulls/1" in url and "/files" not in url:
+                return {
+                    "user": {"login": "author"},
+                    "state": "open",
+                    "head": {"sha": "sha123", "ref": "feat/my-branch"},
+                    "base": {"ref": "main"},
+                    "mergeable": True,
+                    "merged_commit_sha": "merge123",
+                    "title": "My PR",
+                    "body": "Closes #123"
+                }
+            if method == "POST" and "merge" in url:
+                return {}
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}, {"name": "bug", "id": 2}]
+            if method == "GET" and "issues/123" in url:
+                return {"labels": [{"name": "status:in-progress"}, {"name": "bug"}]}
+            if method == "PUT" and "labels" in url:
+                self.assertEqual(payload["labels"], [2])
+                return []
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_merge_pr(pr_number=1, confirmation="MERGE PR 1", do="merge")
+        self.assertTrue(res["performed"])
+        self.assertEqual(res["cleanup_status"].get(123), "released")
+
+    def test_merge_pr_with_branch_name_removes_label(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "GET" and "/user" in url:
+                return {"login": "merger"}
+            if method == "GET" and "pulls/1" in url and "/files" not in url:
+                return {
+                    "user": {"login": "author"},
+                    "state": "open",
+                    "head": {"sha": "sha123", "ref": "fix/issue-123-slug"},
+                    "base": {"ref": "main"},
+                    "mergeable": True,
+                    "merged_commit_sha": "merge123",
+                    "title": "My PR",
+                    "body": "Fixing things"
+                }
+            if method == "POST" and "merge" in url:
+                return {}
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}, {"name": "bug", "id": 2}]
+            if method == "GET" and "issues/123" in url:
+                return {"labels": [{"name": "status:in-progress"}, {"name": "bug"}]}
+            if method == "PUT" and "labels" in url:
+                self.assertEqual(payload["labels"], [2])
+                return []
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_merge_pr(pr_number=1, confirmation="MERGE PR 1", do="merge")
+        self.assertTrue(res["performed"])
+        self.assertEqual(res["cleanup_status"].get(123), "released")
+
+    def test_close_pr_removes_label_but_does_not_close_issue(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "PATCH" and "pulls/1" in url:
+                return {
+                    "number": 1,
+                    "title": "My PR",
+                    "state": "closed",
+                    "html_url": "url",
+                    "body": "Closes #123",
+                    "head": {"ref": "feat/my-branch"}
+                }
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}]
+            if method == "GET" and "issues/123" in url:
+                return {"labels": [{"name": "status:in-progress"}]}
+            if method == "PUT" and "labels" in url:
+                self.assertEqual(payload["labels"], [])
+                return []
+            if method == "POST" and "comments" in url:
+                return {}
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_edit_pr(pr_number=1, state="closed")
+        self.assertTrue(res["success"])
+        self.assertEqual(res["cleanup_status"].get(123), "released")
+
+    def test_multiple_linked_issues(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "PATCH" and "pulls/1" in url:
+                return {
+                    "number": 1,
+                    "title": "My PR",
+                    "state": "closed",
+                    "html_url": "url",
+                    "body": "Closes #123\nFixes #124",
+                    "head": {"ref": "issue-125"}
+                }
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}]
+            if method == "GET" and "issues/123" in url:
+                return {"labels": [{"name": "status:in-progress"}]}
+            if method == "GET" and "issues/124" in url:
+                return {"labels": [{"name": "status:in-progress"}]}
+            if method == "GET" and "issues/125" in url:
+                return {"labels": []}
+            if method == "PUT" and "labels" in url:
+                self.assertEqual(payload["labels"], [])
+                return []
+            if method == "POST" and "comments" in url:
+                return {}
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_edit_pr(pr_number=1, state="closed")
+        self.assertTrue(res["success"])
+        self.assertEqual(res["cleanup_status"].get(123), "released")
+        self.assertEqual(res["cleanup_status"].get(124), "released")
+        self.assertEqual(res["cleanup_status"].get(125), "not present")
+
+    def test_no_linked_issue_found(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "PATCH" and "pulls/1" in url:
+                return {
+                    "number": 1,
+                    "title": "My PR",
+                    "state": "closed",
+                    "html_url": "url",
+                    "body": "No issue link",
+                    "head": {"ref": "main"}
+                }
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_edit_pr(pr_number=1, state="closed")
+        self.assertTrue(res["success"])
+        self.assertEqual(res["cleanup_status"], "no linked issue found")
+
+    def test_label_removal_failure_reported(self):
+        def api_side_effect(method, url, auth, payload=None):
+            if method == "PATCH" and "issues/1" in url:
+                return {"state": "closed"}
+            if method == "GET" and "labels" in url and "issues" not in url:
+                return [{"name": "status:in-progress", "id": 1}]
+            if method == "GET" and "issues/1" in url:
+                return {"labels": [{"name": "status:in-progress"}]}
+            if method == "PUT" and "labels" in url:
+                raise RuntimeError("API failure")
+            return {}
+        self.mock_api.side_effect = api_side_effect
+
+        res = gitea_close_issue(issue_number=1)
+        self.assertTrue(res["success"])
+        self.assertIn("error:", res["cleanup_status"].get(1))