Adds a new MCP resource endpoint to read bugs from Bugzilla (#5293)

Author: suhaibmujahid

bugbug/tools/code_review.py

@@ -517,6 +517,202 @@ def patch_title(self) -> str:
         return self._revision_metadata["fields"]["title"]
 
 
+def create_bug_timeline(comments: list[dict], history: list[dict]) -> list[str]:
+    """Create a unified timeline from bug history and comments."""
+    events = []
+
+    ignored_fields = {"cc", "flagtypes.name"}
+
+    # Add history events
+    for event in history:
+        changes = [
+            change
+            for change in event["changes"]
+            if change["field_name"] not in ignored_fields
+        ]
+        if not changes:
+            continue
+
+        events.append(
+            {
+                "time": event["when"],
+                "type": "change",
+                "who": event["who"],
+                "details": changes,
+            }
+        )
+
+    # Add comments
+    for comment in comments:
+        events.append(
+            {
+                "time": comment["time"],
+                "type": "comment",
+                "who": comment["author"],
+                "id": comment["id"],
+                "count": comment["count"],
+                "text": comment["text"],
+            }
+        )
+
+    # Sort by timestamp
+    events.sort(key=lambda x: (x["time"], x["type"] == "change"))
+
+    # Format timeline
+    timeline = []
+
+    last_event = None
+    for event in events:
+        date = event["time"][:10]
+        time = event["time"][11:19]
+
+        if last_event and last_event["time"] != event["time"]:
+            timeline.append("---\n")
+
+        last_event = event
+
+        if event["type"] == "comment":
+            timeline.append(
+                f"**{date} {time}** - Comment #{event['count']} by {event['who']}"
+            )
+            timeline.append(f"{event['text']}\n")
+        else:
+            timeline.append(f"**{date} {time}** - Changes by {event['who']}")
+            for change in event["details"]:
+                field = change.get("field_name", "unknown")
+                old = change.get("removed", "")
+                new = change.get("added", "")
+                if old or new:
+                    timeline.append(f"  - {field}: '{old}' → '{new}'")
+            timeline.append("")
+
+    return timeline
+
+
+def bug_dict_to_markdown(bug):
+    md_lines = []
+
+    # Header with bug ID and summary
+    md_lines.append(
+        f"# Bug {bug.get('id', 'Unknown')} - {bug.get('summary', 'No summary')}"
+    )
+    md_lines.append("")
+
+    # Basic Information
+    md_lines.append("## Basic Information")
+    md_lines.append(f"- **Status**: {bug.get('status', 'Unknown')}")
+    md_lines.append(f"- **Severity**: {bug.get('severity', 'Unknown')}")
+    md_lines.append(f"- **Product**: {bug.get('product', 'Unknown')}")
+    md_lines.append(f"- **Component**: {bug.get('component', 'Unknown')}")
+    md_lines.append(f"- **Version**: {bug.get('version', 'Unknown')}")
+    md_lines.append(f"- **Platform**: {bug.get('platform', 'Unknown')}")
+    md_lines.append(f"- **OS**: {bug.get('op_sys', 'Unknown')}")
+    md_lines.append(f"- **Created**: {bug.get('creation_time', 'Unknown')}")
+    md_lines.append(f"- **Last Updated**: {bug.get('last_change_time', 'Unknown')}")
+
+    if bug.get("url"):
+        md_lines.append(f"- **Related URL**: {bug['url']}")
+
+    if bug.get("keywords"):
+        md_lines.append(f"- **Keywords**: {', '.join(bug['keywords'])}")
+
+    md_lines.append("")
+
+    # People Involved
+    md_lines.append("## People Involved")
+
+    creator_detail = bug.get("creator_detail", {})
+    if creator_detail:
+        creator_name = creator_detail.get(
+            "real_name",
+            creator_detail.get("nick", creator_detail.get("email", "Unknown")),
+        )
+        md_lines.append(
+            f"- **Reporter**: {creator_name} ({creator_detail.get('email', 'No email')})"
+        )
+
+    assignee_detail = bug.get("assigned_to_detail", {})
+    if assignee_detail:
+        assignee_name = assignee_detail.get(
+            "real_name",
+            assignee_detail.get("nick", assignee_detail.get("email", "Unknown")),
+        )
+        md_lines.append(
+            f"- **Assignee**: {assignee_name} ({assignee_detail.get('email', 'No email')})"
+        )
+
+    # CC List (summarized)
+    cc_count = len(bug.get("cc", []))
+    if cc_count > 0:
+        md_lines.append(f"- **CC Count**: {cc_count} people")
+
+    md_lines.append("")
+
+    # Dependencies and Relationships
+    relationships = []
+    if bug.get("blocks"):
+        relationships.append(f"**Blocks**: {', '.join(map(str, bug['blocks']))}")
+    if bug.get("depends_on"):
+        relationships.append(
+            f"**Depends on**: {', '.join(map(str, bug['depends_on']))}"
+        )
+    if bug.get("regressed_by"):
+        relationships.append(
+            f"**Regressed by**: {', '.join(map(str, bug['regressed_by']))}"
+        )
+    if bug.get("duplicates"):
+        relationships.append(
+            f"**Duplicates**: {', '.join(map(str, bug['duplicates']))}"
+        )
+    if bug.get("see_also"):
+        relationships.append(f"**See also**: {', '.join(bug['see_also'])}")
+
+    if relationships:
+        md_lines.append("## Bug Relationships")
+        for rel in relationships:
+            md_lines.append(f"- {rel}")
+        md_lines.append("")
+
+    timeline = create_bug_timeline(bug["comments"], bug["history"])
+    if timeline:
+        md_lines.append("## Bug Timeline")
+        md_lines.append("")
+        md_lines.extend(timeline)
+
+    return "\n".join(md_lines)
+
+
+class Bug:
+    """Represents a Bugzilla bug from bugzilla.mozilla.org."""
+
+    def __init__(self, data: dict):
+        self.metadata = data
+
+    @staticmethod
+    def get(bug_id: int) -> "Bug":
+        from libmozdata.bugzilla import Bugzilla
+
+        bugs: list[dict] = []
+        Bugzilla(
+            bug_id,
+            include_fields=["_default", "comments", "history"],
+            bughandler=lambda bug, data: data.append(bug),
+            bugdata=bugs,
+        ).get_data().wait()
+
+        if not bugs:
+            raise ValueError(f"Bug {bug_id} not found")
+
+        bug_data = bugs[0]
+        assert bug_data["id"] == bug_id
+
+        return Bug(bug_data)
+
+    def to_md(self) -> str:
+        """Return a markdown representation of the bug."""
+        return bug_dict_to_markdown(self.metadata)
+
+
 class ReviewData(ABC):
     NIT_PATTERN = re.compile(r"[^a-zA-Z0-9]nit[\s:,]", re.IGNORECASE)
 

mcp/pyproject.toml

@@ -7,3 +7,6 @@ dependencies = [
     "bugbug>=0.0.590",
     "fastmcp>=2.12.0",
 ]
+
+[tool.uv.sources]
+bugbug = { path = "..", editable = true }

mcp/src/bugbug_mcp/server.py

@@ -13,7 +13,7 @@
 
 from bugbug import phabricator, utils
 from bugbug.code_search.searchfox_api import FunctionSearchSearchfoxAPI
-from bugbug.tools.code_review import PhabricatorPatch
+from bugbug.tools.code_review import Bug, PhabricatorPatch
 from bugbug.utils import get_secret
 
 mcp = FastMCP("BugBug Code Review MCP Server")
@@ -105,10 +105,15 @@ def get_code_review_tool():
     from bugbug.tools.code_review import CodeReviewTool, ReviewCommentsDB
     from bugbug.vectordb import QdrantVectorDB
 
+    # FIXME: This is a workaround, we should refactor CodeReviewTool to avoid this.
+    class MockLLM(RunnablePassthrough):
+        def bind_tools(self, *args, **kwargs):
+            return self
+
     review_comments_db = ReviewCommentsDB(QdrantVectorDB("diff_comments"))
 
     tool = CodeReviewTool(
-        [RunnablePassthrough()],
+        MockLLM(),
         review_comments_db=review_comments_db,
     )
 
@@ -212,6 +217,16 @@ def find_function_definition(
     return functions[0].source
 
 
+@mcp.resource(
+    uri="bugzilla://bug/{bug_id}",
+    name="Bugzilla Bug Content",
+    mime_type="text/markdown",
+)
+def handle_bug_view_resource(bug_id: int) -> str:
+    """Retrieve a bug from Bugzilla alongside its change history and comments."""
+    return Bug.get(bug_id).to_md()
+
+
 def main():
     phabricator.set_api_key(
         get_secret("PHABRICATOR_URL"), get_secret("PHABRICATOR_TOKEN")