Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

Add auto-close workflow for issues needing MRE (#2100)

Jeremiah Lowin453454711fa2
diff --git a/.github/workflows/auto-close-duplicates.yml b/.github/workflows/auto-close-duplicates.yml
index c13eff127..c2ee3dfb3 100644
--- a/.github/workflows/auto-close-duplicates.yml
+++ b/.github/workflows/auto-close-duplicates.yml
@@ -12,17 +12,25 @@ jobs:
permissions:
contents: read
issues: write
+ id-token: write
steps:
- name: Checkout repository
uses: actions/checkout@v5
+ - name: Generate Marvin App token
+ id: marvin-token
+ uses: actions/create-github-app-token@v2
+ with:
+ app-id: ${{ secrets.MARVIN_APP_ID }}
+ private-key: ${{ secrets.MARVIN_APP_PRIVATE_KEY }}
+
- name: Install uv
uses: astral-sh/setup-uv@v7
- name: Auto-close duplicate issues
run: uv run scripts/auto_close_duplicates.py
env:
- GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ GITHUB_TOKEN: ${{ steps.marvin-token.outputs.token }}
GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
GITHUB_REPOSITORY_NAME: ${{ github.event.repository.name }}
diff --git a/.github/workflows/auto-close-needs-mre.yml b/.github/workflows/auto-close-needs-mre.yml
new file mode 100644
index 000000000..98d26ccff
--- /dev/null
+++ b/.github/workflows/auto-close-needs-mre.yml
@@ -0,0 +1,36 @@
+name: Auto-close needs MRE issues
+description: Auto-closes issues that need minimal reproducible examples after 7 days of author inactivity
+on:
+ schedule:
+ - cron: "0 9 * * *" # Run daily at 9 AM UTC
+ workflow_dispatch:
+
+jobs:
+ auto-close-needs-mre:
+ runs-on: ubuntu-latest
+ timeout-minutes: 10
+ permissions:
+ contents: read
+ issues: write
+ id-token: write
+
+ steps:
+ - name: Checkout repository
+ uses: actions/checkout@v5
+
+ - name: Generate Marvin App token
+ id: marvin-token
+ uses: actions/create-github-app-token@v2
+ with:
+ app-id: ${{ secrets.MARVIN_APP_ID }}
+ private-key: ${{ secrets.MARVIN_APP_PRIVATE_KEY }}
+
+ - name: Install uv
+ uses: astral-sh/setup-uv@v7
+
+ - name: Auto-close needs MRE issues
+ run: uv run scripts/auto_close_needs_mre.py
+ env:
+ GITHUB_TOKEN: ${{ steps.marvin-token.outputs.token }}
+ GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
+ GITHUB_REPOSITORY_NAME: ${{ github.event.repository.name }}
diff --git a/scripts/auto_close_needs_mre.py b/scripts/auto_close_needs_mre.py
new file mode 100644
index 000000000..6432d4882
--- /dev/null
+++ b/scripts/auto_close_needs_mre.py
@@ -0,0 +1,384 @@
+#!/usr/bin/env python
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+# "httpx",
+# ]
+# ///
+"""
+Auto-close issues that need MRE (Minimal Reproducible Example).
+
+This script runs on a schedule to automatically close issues that have been
+marked as "needs MRE" and haven't received activity from the issue author
+within 7 days.
+"""
+
+import os
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+import httpx
+
+
+@dataclass
+class Issue:
+ """Represents a GitHub issue."""
+
+ number: int
+ title: str
+ state: str
+ created_at: str
+ user_id: int
+ user_login: str
+ body: str | None
+
+
+@dataclass
+class Comment:
+ """Represents a GitHub comment."""
+
+ id: int
+ body: str
+ created_at: str
+ user_id: int
+ user_login: str
+
+
+@dataclass
+class Event:
+ """Represents a GitHub issue event."""
+
+ event: str
+ created_at: str
+ label_name: str | None
+
+
+class GitHubClient:
+ """Client for interacting with GitHub API."""
+
+ def __init__(self, token: str, owner: str, repo: str):
+ self.token = token
+ self.owner = owner
+ self.repo = repo
+ self.headers = {
+ "Authorization": f"token {token}",
+ "Accept": "application/vnd.github.v3+json",
+ }
+ self.base_url = f"https://api.github.com/repos/{owner}/{repo}"
+
+ def get_issues_with_label(
+ self, label: str, page: int = 1, per_page: int = 100
+ ) -> list[Issue]:
+ """Fetch open issues with a specific label."""
+ url = f"{self.base_url}/issues"
+ issues = []
+
+ with httpx.Client() as client:
+ response = client.get(
+ url,
+ headers=self.headers,
+ params={
+ "state": "open",
+ "labels": label,
+ "per_page": per_page,
+ "page": page,
+ },
+ )
+
+ if response.status_code != 200:
+ print(f"Error fetching issues: {response.status_code}")
+ return issues
+
+ data = response.json()
+ for item in data:
+ # Skip pull requests
+ if "pull_request" in item:
+ continue
+
+ issues.append(
+ Issue(
+ number=item["number"],
+ title=item["title"],
+ state=item["state"],
+ created_at=item["created_at"],
+ user_id=item["user"]["id"],
+ user_login=item["user"]["login"],
+ body=item.get("body"),
+ )
+ )
+
+ return issues
+
+ def get_issue_events(self, issue_number: int) -> list[Event]:
+ """Fetch all events for an issue."""
+ url = f"{self.base_url}/issues/{issue_number}/events"
+ events = []
+
+ with httpx.Client() as client:
+ page = 1
+ while True:
+ response = client.get(
+ url, headers=self.headers, params={"page": page, "per_page": 100}
+ )
+
+ if response.status_code != 200:
+ break
+
+ data = response.json()
+ if not data:
+ break
+
+ for event_data in data:
+ label_name = None
+ if event_data["event"] == "labeled" and "label" in event_data:
+ label_name = event_data["label"]["name"]
+
+ events.append(
+ Event(
+ event=event_data["event"],
+ created_at=event_data["created_at"],
+ label_name=label_name,
+ )
+ )
+
+ page += 1
+ if page > 10: # Safety limit
+ break
+
+ return events
+
+ def get_issue_comments(self, issue_number: int) -> list[Comment]:
+ """Fetch all comments for an issue."""
+ url = f"{self.base_url}/issues/{issue_number}/comments"
+ comments = []
+
+ with httpx.Client() as client:
+ page = 1
+ while True:
+ response = client.get(
+ url, headers=self.headers, params={"page": page, "per_page": 100}
+ )
+
+ if response.status_code != 200:
+ break
+
+ data = response.json()
+ if not data:
+ break
+
+ for comment_data in data:
+ comments.append(
+ Comment(
+ id=comment_data["id"],
+ body=comment_data["body"],
+ created_at=comment_data["created_at"],
+ user_id=comment_data["user"]["id"],
+ user_login=comment_data["user"]["login"],
+ )
+ )
+
+ page += 1
+ if page > 10: # Safety limit
+ break
+
+ return comments
+
+ def get_issue_timeline(self, issue_number: int) -> list[dict]:
+ """Fetch timeline events for an issue (includes issue edits)."""
+ url = f"{self.base_url}/issues/{issue_number}/timeline"
+ timeline = []
+
+ with httpx.Client() as client:
+ page = 1
+ while True:
+ response = client.get(
+ url,
+ headers={
+ **self.headers,
+ "Accept": "application/vnd.github.mockingbird-preview+json",
+ },
+ params={"page": page, "per_page": 100},
+ )
+
+ if response.status_code != 200:
+ break
+
+ data = response.json()
+ if not data:
+ break
+
+ timeline.extend(data)
+
+ page += 1
+ if page > 10: # Safety limit
+ break
+
+ return timeline
+
+ def close_issue(self, issue_number: int, comment: str) -> bool:
+ """Close an issue with a comment."""
+ # First add the comment
+ comment_url = f"{self.base_url}/issues/{issue_number}/comments"
+ with httpx.Client() as client:
+ response = client.post(
+ comment_url, headers=self.headers, json={"body": comment}
+ )
+
+ if response.status_code != 201:
+ print(f"Failed to add comment to issue #{issue_number}")
+ return False
+
+ # Then close the issue
+ issue_url = f"{self.base_url}/issues/{issue_number}"
+ with httpx.Client() as client:
+ response = client.patch(
+ issue_url, headers=self.headers, json={"state": "closed"}
+ )
+
+ return response.status_code == 200
+
+
+def find_label_application_date(
+ events: list[Event], label_name: str
+) -> datetime | None:
+ """Find when a specific label was applied to an issue."""
+ # Look for the most recent application of this label
+ for event in reversed(events):
+ if event.event == "labeled" and event.label_name == label_name:
+ return datetime.fromisoformat(event.created_at.replace("Z", "+00:00"))
+ return None
+
+
+def has_author_activity_after(
+ issue: Issue,
+ comments: list[Comment],
+ timeline: list[dict],
+ after_date: datetime,
+) -> bool:
+ """Check if the issue author had any activity after a specific date."""
+ # Check for comments from author
+ for comment in comments:
+ if comment.user_id == issue.user_id:
+ comment_date = datetime.fromisoformat(
+ comment.created_at.replace("Z", "+00:00")
+ )
+ if comment_date > after_date:
+ print(
+ f"Issue #{issue.number}: Author commented after label application"
+ )
+ return True
+
+ # Check for issue body edits from author
+ for event in timeline:
+ if event.get("event") == "renamed" or event.get("event") == "edited":
+ if event.get("actor", {}).get("id") == issue.user_id:
+ event_date = datetime.fromisoformat(
+ event["created_at"].replace("Z", "+00:00")
+ )
+ if event_date > after_date:
+ print(
+ f"Issue #{issue.number}: Author edited issue after label application"
+ )
+ return True
+
+ return False
+
+
+def should_close_as_needs_mre(
+ issue: Issue,
+ label_date: datetime,
+ comments: list[Comment],
+ timeline: list[dict],
+) -> bool:
+ """Determine if an issue should be closed for needing an MRE."""
+ # Check if label is old enough (7 days)
+ seven_days_ago = datetime.now(timezone.utc) - timedelta(days=7)
+
+ if label_date > seven_days_ago:
+ return False
+
+ # Check for author activity after the label was applied
+ if has_author_activity_after(issue, comments, timeline, label_date):
+ return False
+
+ return True
+
+
+def main():
+ """Main entry point for auto-closing needs MRE issues."""
+ print("[DEBUG] Starting auto-close needs MRE script")
+
+ # Get environment variables
+ token = os.environ.get("GITHUB_TOKEN")
+ if not token:
+ raise ValueError("GITHUB_TOKEN environment variable is required")
+
+ owner = os.environ.get("GITHUB_REPOSITORY_OWNER", "jlowin")
+ repo = os.environ.get("GITHUB_REPOSITORY_NAME", "fastmcp")
+
+ print(f"[DEBUG] Repository: {owner}/{repo}")
+
+ # Initialize client
+ client = GitHubClient(token, owner, repo)
+
+ # Get issues with "needs MRE" label
+ all_issues = []
+ page = 1
+
+ while page <= 20: # Safety limit
+ issues = client.get_issues_with_label("needs MRE", page=page)
+ if not issues:
+ break
+ all_issues.extend(issues)
+ page += 1
+
+ print(f"[DEBUG] Found {len(all_issues)} open issues with 'needs MRE' label")
+
+ processed_count = 0
+ closed_count = 0
+
+ for issue in all_issues:
+ processed_count += 1
+
+ if processed_count % 10 == 0:
+ print(f"[DEBUG] Processed {processed_count}/{len(all_issues)} issues")
+
+ # Get events to find when label was applied
+ events = client.get_issue_events(issue.number)
+ label_date = find_label_application_date(events, "needs MRE")
+
+ if not label_date:
+ print(
+ f"[DEBUG] Issue #{issue.number}: Could not find label application date"
+ )
+ continue
+
+ print(
+ f"[DEBUG] Issue #{issue.number}: Label applied on {label_date.isoformat()}"
+ )
+
+ # Get comments and timeline
+ comments = client.get_issue_comments(issue.number)
+ timeline = client.get_issue_timeline(issue.number)
+
+ # Check if we should close
+ if should_close_as_needs_mre(issue, label_date, comments, timeline):
+ close_message = (
+ "This issue is being automatically closed because we requested a minimal reproducible example (MRE) "
+ "7 days ago and haven't received a response from the issue author.\n\n"
+ "**If you can provide an MRE**, please add it as a comment and we'll reopen this issue. "
+ "An MRE should be a complete, runnable code snippet that demonstrates the problem.\n\n"
+ "**If this was closed in error**, please leave a comment explaining the situation and we'll reopen it."
+ )
+
+ if client.close_issue(issue.number, close_message):
+ print(f"[SUCCESS] Closed issue #{issue.number} (needs MRE)")
+ closed_count += 1
+ else:
+ print(f"[ERROR] Failed to close issue #{issue.number}")
+
+ print(f"[DEBUG] Processing complete. Closed {closed_count} issues needing MRE")
+
+
+if __name__ == "__main__":
+ main()