π 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.ymlindex c13eff127..c2ee3dfb3 100644--- a/.github/workflows/auto-close-duplicates.yml+++ b/.github/workflows/auto-close-duplicates.yml@@ -12,17 +12,25 @@ jobs:permissions:contents: readissues: write+ id-token: writesteps:- name: Checkout repositoryuses: 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 uvuses: astral-sh/setup-uv@v7- name: Auto-close duplicate issuesrun: uv run scripts/auto_close_duplicates.pyenv:- 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.ymlnew file mode 100644index 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.pynew file mode 100644index 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()