fastmcp-agents-library-agent-github 0.5.1__tar.gz

fastmcp_agents_library_agent_github-0.5.1/.gitignore

@@ -0,0 +1,183 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.env.*
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+secrets
+
+prompt_suggestions
+agent-working-dir
+
+**/*.bak
+
+storage

fastmcp_agents_library_agent_github-0.5.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: fastmcp-agents-library-agent-github
+Version: 0.5.1
+Summary: Agents for GitHub
+Requires-Python: >=3.13
+Requires-Dist: asyncstdlib>=3.13.1
+Requires-Dist: fastmcp-agents-library-agent-simple-code
+Requires-Dist: fastmcp-agents-library-mcp
+Requires-Dist: fastmcp-ai-agent-bridge-pydantic-ai>=0.1.2
+Requires-Dist: gitpython>=3.1.44

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/agents.py.disabled

@@ -0,0 +1,22 @@
+"""
+This agent is used to triage issues on a GitHub repository.
+"""
+
+from fastmcp_agents.core.models.server_builder import FastMCPAgents
+from fastmcp_agents.library.agent.github.issue_triage import GithubIssueTriageAgent
+from fastmcp_agents.library.agent.github.shared.mcp import github_mcp_server
+
+mcp_servers = {
+    "github": github_mcp_server,
+}
+
+
+server = FastMCPAgents(
+    name="triage-github-issue",
+    mcp=mcp_servers,
+    agents=[GithubIssueTriageAgent()],
+).to_server()
+
+
+if __name__ == "__main__":
+    server.run(transport="sse")

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/gather_background.py

@@ -0,0 +1,92 @@
+"""
+This agent is used to triage issues on a GitHub repository.
+"""
+
+import os
+from typing import Any, Literal
+
+from fastmcp import FastMCP
+from fastmcp.tools.tool import Tool
+from fastmcp_ai_agent_bridge.pydantic_ai import FastMCPToolset
+from pydantic import BaseModel
+from pydantic_ai import Agent
+
+from fastmcp_agents.library.agent.github.shared.logging import configure_console_logging
+from fastmcp_agents.library.mcp.github import repo_restricted_github_mcp
+from fastmcp_agents.library.mcp.nickclyde import duckduckgo_mcp
+
+configure_console_logging()
+
+gather_background_instructions = """
+## Persona & Goal:
+You are a helpful assistant to an open source maintainer. You triage issues posted on a GitHub repository, looking
+to connect them with previous issues posted, open or closed pull requests, and discussions.
+
+{mindset_instructions}
+{confidence_levels}
+{section_guidelines}
+
+You will perform multiple searches against the repository across issues, pull requests, and discussions to identify
+and relevant information for the issue. If you find a relevant related item, you will review the comments or discussion
+under that item to determine if it is related to the issue and how it might be related.
+
+Your goal is to "connect the dots", and gather all related information to assist the maintainer in investigating the issue.
+"""
+
+
+def mcp_servers_factory(owner: str, repo: str) -> dict[str, Any]:
+    return {
+        "duckduckgo": duckduckgo_mcp(),
+        "github": repo_restricted_github_mcp(owner=owner, repo=repo, read_only=True),
+    }
+
+
+def repo_restricted_toolset_factory(owner: str, repo: str) -> FastMCPToolset:
+    return FastMCPToolset.from_mcp_config(
+        mcp_config=mcp_servers_factory(
+            owner=owner,
+            repo=repo,
+        )
+    )
+
+
+class GitHubRelatedIssue(BaseModel):
+    issue_title: str
+    issue_number: int
+    confidence: Literal["high", "medium", "low"]
+    reason: str
+
+
+class GitHubIssueSummary(BaseModel):
+    issue_title: str
+    issue_number: int
+    detailed_summary: str
+    related_issues: list[GitHubRelatedIssue]
+
+
+gather_background_agent = Agent[Any, GitHubIssueSummary](
+    model=os.environ.get("MODEL"),
+    system_prompt=gather_background_instructions,
+    output_type=GitHubIssueSummary,
+)
+
+server = FastMCP[None](name="gather-github-issue-background")
+
+
+async def gather_background(owner: str, repo: str, issue_number: int) -> GitHubIssueSummary:
+    result = await gather_background_agent.run(
+        user_prompt=[
+            f"The issue number to gather background information for is {issue_number}.",
+        ],
+        toolsets=[repo_restricted_toolset_factory(owner=owner, repo=repo)],
+    )
+
+    return result.output
+
+
+gather_background_tool = Tool.from_function(fn=gather_background)
+
+server.add_tool(tool=gather_background_tool)
+
+if __name__ == "__main__":
+    server.run(transport="sse")

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/investigate_issue.py

@@ -0,0 +1,67 @@
+from pathlib import Path
+
+from fastmcp import FastMCP
+from fastmcp.tools.tool import Tool
+from fastmcp_ai_agent_bridge.pydantic_ai import FastMCPToolset
+from pydantic import AnyHttpUrl
+
+from fastmcp_agents.library.agent.github.gather_background import GitHubIssueSummary, gather_background, gather_background_tool
+from fastmcp_agents.library.agent.github.respond_to_issue import respond_to_issue
+from fastmcp_agents.library.agent.simple_code.investigate import InvestigationResponse, investigate_code, investigate_code_tool
+
+fastmcp = FastMCP[None](name="github-issue-triage")
+
+fastmcp.add_tool(gather_background_tool)
+fastmcp.add_tool(investigate_code_tool)
+
+toolset = FastMCPToolset(fastmcp=fastmcp)
+
+
+async def investigate_github_issue(
+    *,
+    owner: str,
+    repo: str,
+    reply_to_owner: str | None = None,
+    reply_to_repo: str | None = None,
+    reply_to_issue_number: int | None = None,
+    code_path: Path | None = None,
+    issue_number: int,
+    reply_to_issue: bool,
+) -> tuple[GitHubIssueSummary, InvestigationResponse, str | None]:
+    issue_summary: GitHubIssueSummary = await gather_background(owner=owner, repo=repo, issue_number=issue_number)
+
+    code_repository: Path | AnyHttpUrl
+
+    if code_path:
+        code_repository = code_path
+    elif owner and repo:
+        code_repository = AnyHttpUrl(f"https://github.com/{owner}/{repo}.git")
+    else:
+        msg = "Either code_path or owner and repo must be provided"
+        raise ValueError(msg)
+
+    investigation_response: InvestigationResponse = await investigate_code(
+        task=issue_summary.detailed_summary,
+        code_repository=code_repository,
+    )
+
+    if not reply_to_issue:
+        return issue_summary, investigation_response, None
+
+    response = await respond_to_issue(
+        owner=reply_to_owner or owner,
+        repo=reply_to_repo or repo,
+        issue_number=reply_to_issue_number or issue_number,
+        issue_summary=issue_summary,
+        investigation=investigation_response,
+    )
+
+    return issue_summary, investigation_response, response
+
+
+investigate_github_issue_tool = Tool.from_function(fn=investigate_github_issue)
+
+fastmcp.add_tool(tool=investigate_github_issue_tool)
+
+if __name__ == "__main__":
+    fastmcp.run(transport="sse")

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/issue_triage.py.disabled

@@ -0,0 +1,191 @@
+"""
+This agent is used to triage issues on a GitHub repository.
+"""
+
+from fastmcp import Context
+from fastmcp.client.client import CallToolResult, Client
+from fastmcp.client.transports import FastMCPTransport
+
+from fastmcp_agents.core.agents.task import TaskAgent
+from fastmcp_agents.core.models.server_builder import FastMCPAgents
+from fastmcp_agents.library.agent.github.shared.git import quick_clone_github_repo
+from fastmcp_agents.library.agent.github.shared.helpers import generate_background, get_issue_background
+from fastmcp_agents.library.agent.github.shared.mcp import github_mcp_server
+from fastmcp_agents.library.agent.simple_code.investigate import server_builder as code_investigate_server_builder
+
+issue_triage_instructions = """
+## Persona & Goal:
+You are an expert software investigator and debugger. Your primary mission is to perform a deep, methodical analysis of issues by
+understanding the exact code paths, conditions, and edge cases that lead to the bug.
+
+{mindset_instructions}
+{confidence_levels}
+{section_guidelines}
+
+## Analysis Process:
+1. Initial Code Investigation
+    - Use the code agent to examine the relevant code files
+    - Look for the specific code mentioned in the issue
+    - Identify related code paths and dependencies
+    - Document the exact code structure and patterns
+    - Document your thought process as you examine the code
+
+2. Behavior Hypothesis
+    - Formulate hypotheses about the intended behavior
+    - Consider mathematical correctness (e.g., division by zero is undefined)
+    - Consider user experience expectations
+    - Consider programming language conventions
+    - Document your reasoning for each hypothesis
+    - Evaluate each hypothesis against the code
+
+3. Issue Context Analysis
+    - Extract key terms and patterns from the code investigation
+    - Use these terms to search for related issues
+    - Look for similar error handling patterns
+    - Identify broader patterns in the codebase
+    - Document how these findings affect your hypotheses
+
+4. Test Analysis
+    - Examine test files to understand current error handling
+    - Look for similar test cases
+    - Identify gaps in test coverage
+    - Document existing error handling patterns
+    - Evaluate if tests align with your hypotheses
+
+5. Related Issues Search
+    - Use specific terms from code investigation
+    - Search for similar error patterns
+    - Look for related documentation issues
+    - Consider feature requests that might be impacted
+    - Document any found relationships with confidence levels
+    - Use expandable sections for low confidence relationships
+    - Consider how related issues affect your hypotheses
+    - List recent issues in the repository to catch related issues that might not match search terms
+    - Review issue titles and bodies for semantic relationships
+    - Look for patterns in how issues are reported and handled
+    - Consider both open and recently closed issues for context
+
+**Desired Outcome:** Produce a comprehensive analysis posted as a comment on GitHub issue `$github_issue_number`. This analysis must:
+* Begin with a clear code investigation summary
+* Present your hypotheses about the intended behavior
+* Document your thought process and reasoning
+* Explain why you believe each hypothesis is correct or incorrect
+* Document exact conditions that trigger the behavior
+* Include a proposed test case that verifies the correct behavior
+* Explain why the behavior occurs at a code level
+* Reference specific lines of code and their behavior
+* Include a section on related issues found during the search
+* Use specific terms from the code investigation in the analysis
+* Conclude with a clear recommendation about whether this is a bug or expected behavior
+"""
+
+
+mcp_servers = {
+    "github": github_mcp_server,
+}
+
+
+def triage_issue(
+    issue_repository_owner: str,
+    issue_repository: str,
+    issue_number: int,
+    code_repository_owner: str | None = None,
+    code_repository: str | None = None,
+):
+    """Triage a GitHub issue."""
+
+    if code_repository_owner is None or code_repository is None:
+        code_repository_owner = issue_repository_owner
+        code_repository = issue_repository
+
+
+class GithubIssueTriageAgent(TaskAgent):
+    """An agent that can triage GitHub issues."""
+
+    name: str = "triage_github_issue"
+
+    instructions: str | None = issue_triage_instructions
+
+    async def __call__(
+        self,
+        ctx: Context,
+        issue_repository_owner: str,
+        issue_repository: str,
+        issue_number: int,
+        code_repository_owner: str | None = None,
+        code_repository: str | None = None,
+    ):
+        """Triage a GitHub issue."""
+
+        if code_repository_owner is None or code_repository is None:
+            code_repository_owner = issue_repository_owner
+            code_repository = issue_repository
+
+        issue_content, comments_content, related_issues_content = await get_issue_background(
+            ctx,
+            issue_repository_owner,
+            issue_repository,
+            issue_number,
+        )
+
+        background: str = generate_background(issue_content, comments_content)
+
+        code_agent_task = """
+        We are investigating the code base for the repository {code_repository_owner}/{code_repository}.
+
+        {background}
+
+        The codebase has been cloned to the following path: `{repo_path}`
+
+        Please investigate the codebase to understand the issue and formulate a detailed analysis of the issue.
+
+        Please provide your analysis as a single markdown block.
+        """
+
+        with quick_clone_github_repo(code_repository_owner, code_repository) as repo_path:
+            code_agent_server = code_investigate_server_builder(root_directory=repo_path)
+            code_agent_client = Client[FastMCPTransport](transport=code_agent_server)
+
+            async with code_agent_client:
+                code_agent_response: CallToolResult = await code_agent_client.call_tool(
+                    "ask_issue_background",
+                    arguments={
+                        "task": code_agent_task.format(
+                            code_repository_owner=code_repository_owner,
+                            code_repository=code_repository,
+                            background=background,
+                            repo_path=repo_path,
+                        ),
+                    },
+                )
+
+        github_agent_task = """
+        Background:
+        ```markdown
+        {background}
+        ```
+
+        We've identified the following potential related issues:
+        ```markdown
+        {github_related_issues}
+        ```
+
+        We have dispatched a code agent to investigate the codebase related to the issue. They have provided the following analysis:
+
+        ```markdown
+        {code_agent_response}
+        ```
+
+        Please formulate a detailed response that can be posted as a comment on the issue.
+        """
+
+
+server = FastMCPAgents(
+    name="triage-github-issue",
+    mcp=mcp_servers,
+    agents=[GithubIssueTriageAgent()],
+).to_server()
+
+
+if __name__ == "__main__":
+    server.run(transport="sse")

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/respond_to_issue.py

@@ -0,0 +1,98 @@
+"""
+This agent is used to triage issues on a GitHub repository.
+"""
+
+import os
+from textwrap import dedent
+from typing import Any
+
+import yaml
+from fastmcp import FastMCP
+from fastmcp_ai_agent_bridge.pydantic_ai import FastMCPToolset
+from pydantic_ai import Agent
+
+from fastmcp_agents.library.agent.github.gather_background import GitHubIssueSummary
+from fastmcp_agents.library.agent.github.shared.logging import configure_console_logging
+from fastmcp_agents.library.agent.simple_code.investigate import InvestigationResponse
+from fastmcp_agents.library.mcp.github import repo_restricted_github_mcp
+
+configure_console_logging()
+
+respond_instructions = """
+## Persona & Goal:
+You are a helpful assistant to an open source maintainer. You receive a bunch of background about an issue
+and a triage performed by another maintainer and you reponse on the issue.
+
+{mindset_instructions}
+{confidence_levels}
+{section_guidelines}
+
+Your goal is to reflect all of the details of the triage and background while producing a nicely formatted markdown response
+in the GitHub comment. When you complete the task and report success include the body of the reponse of the comment.
+"""
+
+
+def mcp_servers_factory(owner: str, repo: str) -> dict[str, Any]:
+    return {
+        "github": repo_restricted_github_mcp(
+            owner=owner,
+            repo=repo,
+            issues=True,
+            pull_requests=False,
+            discussions=False,
+            repository=False,
+        ),
+    }
+
+
+def repo_restricted_toolset_factory(owner: str, repo: str) -> FastMCPToolset:
+    return FastMCPToolset.from_mcp_config(
+        mcp_config=mcp_servers_factory(
+            owner=owner,
+            repo=repo,
+        )
+    )
+
+
+issue_response_agent = Agent[Any, str](
+    model=os.environ.get("MODEL"),
+    system_prompt=respond_instructions,
+    output_type=str,
+)
+
+server = FastMCP[None](name="respond-to-github-issue-background")
+
+
+async def respond_to_issue(
+    owner: str,
+    repo: str,
+    issue_number: int,
+    issue_summary: GitHubIssueSummary,
+    investigation: InvestigationResponse | None = None,
+) -> str:
+    background_yaml = yaml.safe_dump(issue_summary.model_dump())
+    investigation_yaml = yaml.safe_dump(data=investigation.model_dump()) if investigation else None
+
+    task = dedent(
+        text=f"""The issue number to reply to is {issue_number}.
+
+    The background information is as follows:
+    {background_yaml}
+    """
+    ).strip()
+
+    if investigation:
+        task += dedent(
+            text=f"""
+        The investigation response is as follows:
+        {investigation_yaml}
+        """
+        ).strip()
+
+    run_result = await issue_response_agent.run(
+        user_prompt=task, toolsets=[repo_restricted_toolset_factory(owner=owner, repo=repo)], output_type=str
+    )
+
+    print(run_result.output)
+
+    return run_result.output

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/shared/git.py

@@ -0,0 +1,2 @@
+def get_repo_url(owner: str, repository: str) -> str:
+    return f"https://github.com/{owner}/{repository}.git"

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/shared/helpers.py

@@ -0,0 +1,213 @@
+from typing import Annotated, Literal
+
+from fastmcp import Context
+from fastmcp.tools import FunctionTool
+from fastmcp.tools.tool import ToolResult
+from fastmcp.tools.tool_transform import ArgTransform, TransformedTool
+
+from fastmcp_agents.core.agents.base import FastMCPTool
+from fastmcp_agents.core.utilities.mcp import get_text_from_tool_result
+
+# async def get_issue(ctx: Context, owner: str, repo: str, issue_number: int) -> ToolResult:
+#     github_issue: ToolResult = await ctx.fastmcp._call_tool(
+#         "get_issue",
+#         arguments={
+#             "owner": owner,
+#             "repo": repo,
+#             "issue_number": issue_number,
+#         },
+#     )
+
+#     return github_issue
+
+
+# async def get_issue_comments(ctx: Context, owner: str, repo: str, issue_number: int) -> ToolResult:
+#     github_issue_comments: ToolResult = await ctx.fastmcp._call_tool(
+#         "get_issue_comments",
+#         arguments={
+#             "owner": owner,
+#             "repo": repo,
+#             "per_page": 100,
+#             "issue_number": issue_number,
+#         },
+#     )
+
+#     return github_issue_comments
+
+
+# class RelatedKeywords(BaseModel):
+#     keywords: list[str]
+
+
+# class RelatedIssues(BaseModel):
+#     issue_numbers: list[int]
+
+
+# async def related_issues_completion(ctx: Context, owner: str, repo: str, background: str) -> list[ContentBlock]:
+#     def provide_keywords(keywords: list[str]) -> RelatedKeywords:
+#         return RelatedKeywords(keywords=keywords)
+
+#     _, _, pending_tool_call = await ctx.completions.tool(
+#         system_prompt="""Review the background information for the following GitHub issue and provide a list of important
+#         keywords that can be used to search for related issues. Provide no more than 5 keywords.""",
+#         messages=background,
+#         tools=[FunctionTool.from_function(fn=provide_keywords)],
+#     )
+
+#     _, result = await pending_tool_call.run()
+
+#     if isinstance(result, ToolError):
+#         raise result
+
+#     keywords: list[str] = result.structured_content.get("keywords", []) if result.structured_content else []
+
+#     related_issues_search: ToolResult = await search_issues(ctx, owner, repo, keywords)
+
+#     def provide_issue_numbers(issue_numbers: list[int]) -> RelatedIssues:
+#         return RelatedIssues(issue_numbers=issue_numbers)
+
+#     _, _, pending_tool_call = await ctx.completions.tool(
+#         system_prompt="""
+#         Review the background information for the following GitHub issue and the provided list of search results and provide a
+#         list of likely related issue numbers from the search results.",
+#         """,
+#         messages=[
+#             background,
+#             str(related_issues_search.structured_content),
+#         ],
+#         tools=[FunctionTool.from_function(fn=provide_issue_numbers)],
+#     )
+
+#     _, result = await pending_tool_call.run()
+
+#     if isinstance(result, ToolError):
+#         raise result
+
+#     issue_numbers: list[int] = result.structured_content.get("issue_numbers", []) if result.structured_content else []
+
+#     related_issues: list[ToolResult] = [await get_issue(ctx, owner, repo, issue_number) for issue_number in issue_numbers]
+
+#     issues: list[ContentBlock] = []
+
+#     for related_issue in related_issues:
+#         issues.extend(related_issue.content)
+
+#     return issues
+
+
+async def search_issues(
+    ctx: Context,
+    owner: str,
+    repo: str,
+    keywords: Annotated[list[str], "The keywords to search for. Maximum of 5 keywords."],
+    state: Literal["all", "open", "closed"] = "all",
+) -> ToolResult:
+    """Search for issues by keyword in a GitHub repo. If more than 5 keywords are provided, only the first 5 will be used."""
+
+    search_query_parts: list[str] = ["is:issue", f"repo:{owner}/{repo}"]
+
+    if state == "open":
+        search_query_parts.append("state:open")
+    elif state == "closed":
+        search_query_parts.append("state:closed")
+
+    search_query_parts.append(" OR ".join(keywords[:5]))
+
+    github_issues: ToolResult = await ctx.fastmcp._call_tool(
+        "search_issues",
+        arguments={
+            "q": " ".join(search_query_parts),
+        },
+    )
+
+    return github_issues
+
+
+search_issues_tool = FunctionTool.from_function(fn=search_issues)
+
+
+async def get_issue_background(
+    tools: dict[str, FastMCPTool],
+    owner: str,
+    repo: str,
+    issue_number: int,
+) -> tuple[str, str]:
+    get_issue_tool: FastMCPTool | None = tools.get("get_issue")
+
+    if get_issue_tool is None:
+        msg = "get_issue tool not found"
+        raise ValueError(msg)
+
+    get_issue_comments_tool: FastMCPTool | None = tools.get("get_issue_comments")
+
+    if get_issue_comments_tool is None:
+        msg = "get_issue_comments tool not found"
+        raise ValueError(msg)
+
+    issue = await get_issue_tool.run(arguments={"owner": owner, "repo": repo, "issue_number": issue_number})
+
+    issue_content: str = get_text_from_tool_result(issue)
+
+    comments = await get_issue_comments_tool.run(arguments={"owner": owner, "repo": repo, "issue_number": issue_number})
+
+    comments_content: str = get_text_from_tool_result(comments)
+
+    return issue_content, comments_content
+
+
+def owner_repo_args_transform_factory(owner: str, repo: str) -> dict[str, ArgTransform]:
+    return {
+        "owner": ArgTransform(default=owner, hide=True),
+        "repo": ArgTransform(default=repo, hide=True),
+    }
+
+
+async def restricted_get_issue_tool_factory(tools: dict[str, FastMCPTool], owner: str, repo: str) -> TransformedTool:
+    if get_issue_tool := tools.get("get_issue"):
+        return TransformedTool.from_tool(
+            get_issue_tool,
+            transform_args=owner_repo_args_transform_factory(owner, repo),
+        )
+
+    msg = "get_issue tool not found"
+    raise ValueError(msg)
+
+
+async def restricted_get_pull_request_tool_factory(tools: dict[str, FastMCPTool], owner: str, repo: str) -> TransformedTool:
+    if get_pull_request_tool := tools.get("get_pull_request"):
+        return TransformedTool.from_tool(
+            get_pull_request_tool,
+            transform_args=owner_repo_args_transform_factory(owner, repo),
+        )
+
+    msg = "get_pull_request tool not found"
+    raise ValueError(msg)
+
+
+async def restricted_search_issues_tool_factory(owner: str, repo: str) -> TransformedTool:
+    return TransformedTool.from_tool(
+        search_issues_tool,
+        transform_args=owner_repo_args_transform_factory(owner, repo),
+    )
+
+
+def generate_background(issue_content: str, comments_content: str, extra: str | None = None) -> str:
+    """Generate a background for an issue."""
+    background: str = f"""
+    An issue has been reported in the repo.
+
+    ```markdown
+    {issue_content}
+    ```
+
+    There may be some discussion in the issue comments.
+
+    ```markdown
+    {comments_content}
+    ```
+    """
+
+    if extra:
+        background += f"\n\n{extra}"
+
+    return background

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/shared/logging.py

@@ -0,0 +1,113 @@
+import json
+from datetime import UTC, datetime
+
+import logfire
+from logfire import ConsoleOptions
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
+from pydantic_ai import Agent
+
+
+def get_tool_names_from_span(span: ReadableSpan) -> list[str]:
+    if not span.attributes:
+        return []
+
+    if not (model_request_parameters := span.attributes.get("model_request_parameters")):
+        return []
+
+    if not isinstance(model_request_parameters, str):
+        return []
+
+    deserialized_model_request_parameters = json.loads(model_request_parameters)
+
+    if not (function_tools := deserialized_model_request_parameters.get("function_tools")):
+        return []
+
+    return [tool["name"] for tool in function_tools]
+
+
+def get_picked_tools_from_span(span: ReadableSpan) -> list[str]:
+    if not span.attributes:
+        return []
+
+    if not (events := span.attributes.get("events")):
+        return []
+
+    if not isinstance(events, str):
+        return []
+
+    deserialized_events = json.loads(events)
+
+    assistant_event = deserialized_events[-1]
+
+    if not (message := assistant_event.get("message")):
+        return []
+
+    if not (tool_calls := message.get("tool_calls")):
+        return []
+
+    return [
+        tool_call.get(
+            "function",
+            {},
+        ).get(
+            "name",
+            "<unknown>",
+        )
+        for tool_call in tool_calls
+        if tool_call.get("type") == "function"
+    ]
+
+
+ADDT_FORMAT_SPAN_NAMES = {"running tool"}
+
+
+def format_span(span: ReadableSpan) -> str:
+    timestamp: datetime | None = datetime.fromtimestamp(span.start_time / 1_000_000_000, tz=UTC) if span.start_time else None
+
+    span_message = span.name
+
+    message = "{timestamp} - {span_message}\n"
+    default_message = message.format(timestamp=timestamp, span_message=span_message)
+
+    if not span.attributes:
+        return default_message
+
+    if not span.name.startswith("chat ") and span.name not in ADDT_FORMAT_SPAN_NAMES:
+        return default_message
+
+    match span.name:
+        case "running tool":
+            model_name: str | None = str(span.attributes.get("gen_ai.request.model"))
+            tool_name: str | None = str(span.attributes.get("gen_ai.tool.name"))
+            tool_arguments: str | None = str(span.attributes.get("tool_arguments"))
+            tool_response: str | None = str(span.attributes.get("tool_response"))
+
+            span_message = f"Model called {tool_name} with arguments: {tool_arguments} returned: {tool_response[:200]}"
+
+        case _ if span.name.startswith("chat "):
+            model_name: str | None = str(span.attributes.get("gen_ai.request.model"))
+            # tool_names: list[str] = get_tool_names_from_span(span)
+            picked_tools: list[str] = get_picked_tools_from_span(span)
+            span_message = f"Model: {model_name} -- Picked tools: {picked_tools}"
+
+        case _:
+            span_message = span.name
+
+    return message.format(timestamp=timestamp, span_message=span_message)
+
+
+def configure_console_logging():
+    Agent.instrument_all()
+
+    _ = logfire.configure(
+        send_to_logfire=False,
+        console=ConsoleOptions(),
+        additional_span_processors=[
+            SimpleSpanProcessor(
+                span_exporter=ConsoleSpanExporter(
+                    formatter=format_span,
+                )
+            )
+        ],
+    )

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/shared/mcp.py

@@ -0,0 +1,16 @@
+import os
+
+github_mcp_server = {
+    "command": "docker",
+    "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e",
+        "GITHUB_PERSONAL_ACCESS_TOKEN",
+        "ghcr.io/github/github-mcp-server",
+    ],
+    "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN"),
+    },
+}

fastmcp_agents_library_agent_github-0.5.1/fastmcp_agents/library/agent/github/shared/prompts.py

@@ -0,0 +1,38 @@
+confidence_levels = """
+## Confidence Levels and Presentation:
+* High Confidence (90-100%):
+    - Present findings directly in the main response
+    - Provide clear evidence and explanations
+    - Include specific code references
+* Medium Confidence (50-89%):
+    - Present findings in the main response
+    - Clearly state confidence level
+    - Explain why you're not completely certain
+* Low Confidence (0-49%):
+    - Hide findings in an expandable section using GitHub's details/summary syntax:
+    ```markdown
+    <details>
+    <summary>Low Confidence Findings (Click to expand)</summary>
+
+    [Your low confidence findings here]
+    </details>
+    ```
+    - Explain why confidence is low
+    - Suggest what additional information would increase confidence
+"""
+
+mindset_instructions = """
+## Mindset: Approach each task with:
+* Accuracy - ensure findings are truly relevant
+* Clarity - present findings in a clear, organized manner
+* Honesty - be explicit about confidence levels and hide low confidence findings in expandable sections
+"""
+
+section_guidelines = """
+## Section Guidelines:
+* Only include sections that are relevant to the current task
+* Skip sections where you have no findings or insights to share
+* If a section would be empty, omit it entirely rather than including it with no content
+* Focus on quality over quantity - better to have fewer, well-analyzed sections than many empty ones
+* If you're unsure whether a section is relevant, err on the side of omitting it
+"""

fastmcp_agents_library_agent_github-0.5.1/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "fastmcp-agents-library-agent-github"
+version = "0.5.1"
+description = "Agents for GitHub"
+readme = "README.md"
+requires-python = ">=3.13"
+
+dependencies = [
+    "asyncstdlib>=3.13.1",
+    "fastmcp-agents-library-agent-simple-code",
+    "fastmcp-agents-library-mcp",
+    "fastmcp-ai-agent-bridge-pydantic-ai>=0.1.2",
+    "gitpython>=3.1.44",
+]
+
+[project.scripts]
+github-issue-triage = "fastmcp_agents.library.agent.github.issue_triage:main"
+github-gather-background = "fastmcp_agents.library.agent.github.gather_background:main"
+
+[dependency-groups]
+dev = [
+    "pytest-asyncio>=1.1.0",
+    "pytest-dotenv",
+    "ruff>=0.12.4",
+]
+
+[tool.uv.sources]
+fastmcp-agents-library-agent-simple-code = { workspace = true }
+fastmcp-agents-library-mcp = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+markers = [
+    "skip_on_ci: Skip running the test when running on CI",
+]
+include =["./tests"]
+ignore = ["./playground"]
+addopts = "-s" 
+env_files = [".env"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/fastmcp_agents"]
+
+[tool.hatch.build.targets.sdist]
+packages = ["src/fastmcp_agents"]
+
+[tool.ruff]
+extend="../../../pyproject.toml"
+
+[tool.pyright]
+extends = "../../../pyproject.toml"