fastmcp-agents-library-agent-github 0.5.1__py3-none-any.whl → 0.5.5__py3-none-any.whl

fastmcp_agents/library/agent/github/gather_background.py

@@ -0,0 +1,97 @@
+"""
+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)
+
+
+def run():
+    server.run()
+
+
+if __name__ == "__main__":
+    server.run(transport="sse")

fastmcp_agents/library/agent/github/investigate_issue.py

@@ -0,0 +1,72 @@
+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)
+
+
+def run():
+    fastmcp.run()
+
+
+if __name__ == "__main__":
+    fastmcp.run(transport="sse")

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/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/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/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/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/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.dist-info → fastmcp_agents_library_agent_github-0.5.5.dist-info}/METADATA

@@ -1,10 +1,12 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: fastmcp-agents-library-agent-github
-Version: 0.5.1
+Version: 0.5.5
 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
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+

fastmcp_agents_library_agent_github-0.5.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+fastmcp_agents/library/agent/github/__init__.py,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
+fastmcp_agents/library/agent/github/gather_background.py,sha256=6aa1d908a36f54cbdd437994109fd7994c94494fa962802ad94b2a5024ae0238,2903
+fastmcp_agents/library/agent/github/investigate_issue.py,sha256=6841d9926ffea3908782075bb01555f938c3d0e915cf8fb8d526d5802171bf7a,2283
+fastmcp_agents/library/agent/github/respond_to_issue.py,sha256=0d0a9b5712a66d5eabdf7a2c1db5a596ffdd962e491593df4d07010c3ec86e79,2848
+fastmcp_agents/library/agent/github/shared/git.py,sha256=200e22082c2ae038895dea85b08e10f42f071f56ae802b672dba51fd2158b7e8,112
+fastmcp_agents/library/agent/github/shared/helpers.py,sha256=4d4a39922c829675678d2a362957f91146938a7c2dfd4bd2bbbe5e1f905c5ee4,6904
+fastmcp_agents/library/agent/github/shared/logging.py,sha256=788f61791cb02232ca2d4f30575441751c8b87d2b6993615c9a546954a219df9,3436
+fastmcp_agents/library/agent/github/shared/mcp.py,sha256=f19ca673a531953a70bc51043e138e48a2c6d90d751e0558442f1511f2837d41,327
+fastmcp_agents/library/agent/github/shared/prompts.py,sha256=eaae4fcbb1603d79540fc5174138d543c00e6df5f4c1ec33fe8489bd23c59896,1495
+fastmcp_agents_library_agent_github-0.5.5.dist-info/WHEEL,sha256=03f80d698bb4300c27bcafc3987ea73ef427fcb365e59e808e50d041a7f87b89,78
+fastmcp_agents_library_agent_github-0.5.5.dist-info/entry_points.txt,sha256=4a99925805bb82d01b31152188036ecd8c968048a4d5cdc8055fc359d488d6f7,189
+fastmcp_agents_library_agent_github-0.5.5.dist-info/METADATA,sha256=adc1c310b828fab791c397f29dabeded92325acfdbc0d4698f2511b0c60a7a10,395
+fastmcp_agents_library_agent_github-0.5.5.dist-info/RECORD,,

fastmcp_agents_library_agent_github-0.5.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.2
+Root-Is-Purelib: true
+Tag: py3-none-any

fastmcp_agents_library_agent_github-0.5.5.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+github-gather-background = fastmcp_agents.library.agent.github.gather_background:run
+github-investigate-issue = fastmcp_agents.library.agent.github.investigate_issue:run
+

fastmcp_agents_library_agent_github-0.5.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-fastmcp_agents_library_agent_github-0.5.1.dist-info/METADATA,sha256=Xo0H-I_nBPa7mpzPRqxAWqC8MAQLk5Pzp_OcSPkI30o,354
-fastmcp_agents_library_agent_github-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp_agents_library_agent_github-0.5.1.dist-info/entry_points.txt,sha256=Co3KZ71gxHFiJ32ukLPTXedx5xvMAkrlo3RElZbnp2c,180
-fastmcp_agents_library_agent_github-0.5.1.dist-info/RECORD,,

fastmcp_agents_library_agent_github-0.5.1.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: hatchling 1.27.0
-Root-Is-Purelib: true
-Tag: py3-none-any

fastmcp_agents_library_agent_github-0.5.1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-github-gather-background = fastmcp_agents.library.agent.github.gather_background:main
-github-issue-triage = fastmcp_agents.library.agent.github.issue_triage:main