github-agent 0.1.1__py3-none-any.whl

github_agent/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

github_agent/github_agent.py

@@ -0,0 +1,751 @@
+#!/usr/bin/python
+# coding: utf-8
+import json
+import os
+import argparse
+import logging
+import uvicorn
+from typing import Optional, Any
+from contextlib import asynccontextmanager
+
+from pydantic_ai import Agent, ModelSettings, RunContext
+from pydantic_ai.mcp import load_mcp_servers, MCPServerStreamableHTTP, MCPServerSSE
+from pydantic_ai_skills import SkillsToolset
+from fasta2a import Skill
+from github_agent.utils import (
+    to_integer,
+    to_boolean,
+    to_float,
+    to_list,
+    to_dict,
+    get_mcp_config_path,
+    get_skills_path,
+    load_skills_from_directory,
+    create_model,
+    tool_in_tag,
+    prune_large_messages,
+)
+
+from fastapi import FastAPI, Request
+from starlette.responses import Response, StreamingResponse
+from pydantic import ValidationError
+from pydantic_ai.ui import SSE_CONTENT_TYPE
+from pydantic_ai.ui.ag_ui import AGUIAdapter
+
+__version__ = "0.1.1"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logging.getLogger("pydantic_ai").setLevel(logging.INFO)
+logging.getLogger("fastmcp").setLevel(logging.INFO)
+logging.getLogger("httpx").setLevel(logging.INFO)
+logger = logging.getLogger(__name__)
+
+DEFAULT_HOST = os.getenv("HOST", "0.0.0.0")
+DEFAULT_PORT = to_integer(string=os.getenv("PORT", "9000"))
+DEFAULT_DEBUG = to_boolean(string=os.getenv("DEBUG", "False"))
+DEFAULT_PROVIDER = os.getenv("PROVIDER", "openai")
+DEFAULT_MODEL_ID = os.getenv("MODEL_ID", "qwen/qwen3-4b-2507")
+DEFAULT_OPENAI_BASE_URL = os.getenv(
+    "OPENAI_BASE_URL", "http://host.docker.internal:1234/v1"
+)
+DEFAULT_OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "ollama")
+DEFAULT_MCP_URL = os.getenv("MCP_URL", None)
+DEFAULT_MCP_CONFIG = os.getenv("MCP_CONFIG", get_mcp_config_path())
+DEFAULT_SKILLS_DIRECTORY = os.getenv("SKILLS_DIRECTORY", get_skills_path())
+DEFAULT_ENABLE_WEB_UI = to_boolean(os.getenv("ENABLE_WEB_UI", "False"))
+
+# Model Settings
+DEFAULT_MAX_TOKENS = to_integer(os.getenv("MAX_TOKENS", "8192"))
+DEFAULT_TEMPERATURE = to_float(os.getenv("TEMPERATURE", "0.7"))
+DEFAULT_TOP_P = to_float(os.getenv("TOP_P", "1.0"))
+DEFAULT_TIMEOUT = to_float(os.getenv("TIMEOUT", "32400.0"))
+DEFAULT_TOOL_TIMEOUT = to_float(os.getenv("TOOL_TIMEOUT", "32400.0"))
+DEFAULT_PARALLEL_TOOL_CALLS = to_boolean(os.getenv("PARALLEL_TOOL_CALLS", "True"))
+DEFAULT_SEED = to_integer(os.getenv("SEED", None))
+DEFAULT_PRESENCE_PENALTY = to_float(os.getenv("PRESENCE_PENALTY", "0.0"))
+DEFAULT_FREQUENCY_PENALTY = to_float(os.getenv("FREQUENCY_PENALTY", "0.0"))
+DEFAULT_LOGIT_BIAS = to_dict(os.getenv("LOGIT_BIAS", None))
+DEFAULT_STOP_SEQUENCES = to_list(os.getenv("STOP_SEQUENCES", None))
+DEFAULT_EXTRA_HEADERS = to_dict(os.getenv("EXTRA_HEADERS", None))
+DEFAULT_EXTRA_BODY = to_dict(os.getenv("EXTRA_BODY", None))
+
+AGENT_NAME = "GitHubAgent"
+AGENT_DESCRIPTION = (
+    "A multi-agent system for interacting with GitHub via delegated specialists."
+)
+
+# -------------------------------------------------------------------------
+# 1. System Prompts
+# -------------------------------------------------------------------------
+
+SUPERVISOR_SYSTEM_PROMPT = os.environ.get(
+    "SUPERVISOR_SYSTEM_PROMPT",
+    default=(
+        "You are the GitHub Supervisor Agent.\n"
+        "Your goal is to assist the user by assigning tasks to specialized child agents through your available toolset.\n"
+        "Analyze the user's request and determine which domain(s) it falls into (e.g., issues, pull requests, repos, etc.).\n"
+        "Then, call the appropriate tool(s) to delegate the task.\n"
+        "Synthesize the results from the child agents into a final helpful response.\n"
+        "Always be warm, professional, and helpful.\n"
+        "Note: The final response should contain all the relevant information from the tool executions."
+    ),
+)
+
+CONTEXT_AGENT_PROMPT = os.environ.get(
+    "CONTEXT_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Context Agent. "
+        "Your goal is to provide context about the current user and functionality within GitHub."
+    ),
+)
+
+ACTIONS_AGENT_PROMPT = os.environ.get(
+    "ACTIONS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Actions Agent. "
+        "Your goal is to manage GitHub Actions workflows and CI/CD operations."
+    ),
+)
+
+CODE_SECURITY_AGENT_PROMPT = os.environ.get(
+    "CODE_SECURITY_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Code Security Agent. "
+        "Your goal is to manage code security tools and scans."
+    ),
+)
+
+DEPENDABOT_AGENT_PROMPT = os.environ.get(
+    "DEPENDABOT_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Dependabot Agent. "
+        "Your goal is to manage Dependabot alerts and configurations."
+    ),
+)
+
+DISCUSSIONS_AGENT_PROMPT = os.environ.get(
+    "DISCUSSIONS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Discussions Agent. "
+        "Your goal is to manage GitHub Discussions."
+    ),
+)
+
+GISTS_AGENT_PROMPT = os.environ.get(
+    "GISTS_AGENT_PROMPT",
+    default=("You are the GitHub Gists Agent. " "Your goal is to manage GitHub Gists."),
+)
+
+GIT_AGENT_PROMPT = os.environ.get(
+    "GIT_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Git Agent. "
+        "Your goal is to perform low-level Git operations via the GitHub API (e.g., refs, trees, blobs)."
+    ),
+)
+
+ISSUES_AGENT_PROMPT = os.environ.get(
+    "ISSUES_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Issues Agent. "
+        "Your goal is to manage GitHub Issues (create, list, update, comment)."
+    ),
+)
+
+LABELS_AGENT_PROMPT = os.environ.get(
+    "LABELS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Labels Agent. " "Your goal is to manage repository labels."
+    ),
+)
+
+NOTIFICATIONS_AGENT_PROMPT = os.environ.get(
+    "NOTIFICATIONS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Notifications Agent. "
+        "Your goal is to manage and check GitHub notifications."
+    ),
+)
+
+ORGS_AGENT_PROMPT = os.environ.get(
+    "ORGS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Organizations Agent. "
+        "Your goal is to manage GitHub Organizations and memberships."
+    ),
+)
+
+PROJECTS_AGENT_PROMPT = os.environ.get(
+    "PROJECTS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Projects Agent. "
+        "Your goal is to manage GitHub Projects (V2/Beta)."
+    ),
+)
+
+PULL_REQUESTS_AGENT_PROMPT = os.environ.get(
+    "PULL_REQUESTS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Pull Requests Agent. "
+        "Your goal is to manage Pull Requests (list, create, review, merge)."
+    ),
+)
+
+REPOS_AGENT_PROMPT = os.environ.get(
+    "REPOS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Repositories Agent. "
+        "Your goal is to manage GitHub Repositories (create, list, delete, settings)."
+    ),
+)
+
+SECRET_PROTECTION_AGENT_PROMPT = os.environ.get(
+    "SECRET_PROTECTION_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Secret Protection Agent. "
+        "Your goal is to manage secret scanning and protection features."
+    ),
+)
+
+SECURITY_ADVISORIES_AGENT_PROMPT = os.environ.get(
+    "SECURITY_ADVISORIES_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Security Advisories Agent. "
+        "Your goal is to access and manage security advisories."
+    ),
+)
+
+STARGAZERS_AGENT_PROMPT = os.environ.get(
+    "STARGAZERS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Stargazers Agent. "
+        "Your goal is to manage and view repository stargazers."
+    ),
+)
+
+USERS_AGENT_PROMPT = os.environ.get(
+    "USERS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Users Agent. "
+        "Your goal is to access public user information and profile data."
+    ),
+)
+
+COPILOT_AGENT_PROMPT = os.environ.get(
+    "COPILOT_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Copilot Agent. "
+        "Your goal is to assist with coding tasks using GitHub Copilot."
+    ),
+)
+
+COPILOT_SPACES_AGENT_PROMPT = os.environ.get(
+    "COPILOT_SPACES_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Copilot Spaces Agent. "
+        "Your goal is to manage Copilot Spaces."
+    ),
+)
+
+SUPPORT_DOCS_AGENT_PROMPT = os.environ.get(
+    "SUPPORT_DOCS_AGENT_PROMPT",
+    default=(
+        "You are the GitHub Support Docs Agent. "
+        "Your goal is to search GitHub documentation to answer support questions."
+    ),
+)
+
+
+# -------------------------------------------------------------------------
+# 2. Agent Creation Logic
+# -------------------------------------------------------------------------
+
+
+def create_agent(
+    provider: str = DEFAULT_PROVIDER,
+    model_id: str = DEFAULT_MODEL_ID,
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    mcp_url: str = DEFAULT_MCP_URL,
+    mcp_config: str = DEFAULT_MCP_CONFIG,
+    skills_directory: Optional[str] = DEFAULT_SKILLS_DIRECTORY,
+) -> Agent:
+    """
+    Creates the Supervisor Agent with sub-agents registered as tools.
+    """
+    logger.info("Initializing Multi-Agent System for GitHub...")
+
+    model = create_model(provider, model_id, base_url, api_key)
+    settings = ModelSettings(
+        max_tokens=DEFAULT_MAX_TOKENS,
+        temperature=DEFAULT_TEMPERATURE,
+        top_p=DEFAULT_TOP_P,
+        timeout=DEFAULT_TIMEOUT,
+        parallel_tool_calls=DEFAULT_PARALLEL_TOOL_CALLS,
+        seed=DEFAULT_SEED,
+        presence_penalty=DEFAULT_PRESENCE_PENALTY,
+        frequency_penalty=DEFAULT_FREQUENCY_PENALTY,
+        logit_bias=DEFAULT_LOGIT_BIAS,
+        stop_sequences=DEFAULT_STOP_SEQUENCES,
+        extra_headers=DEFAULT_EXTRA_HEADERS,
+        extra_body=DEFAULT_EXTRA_BODY,
+    )
+
+    # Load master toolsets
+    master_toolsets = []
+    if mcp_config:
+        mcp_toolset = load_mcp_servers(mcp_config)
+        master_toolsets.extend(mcp_toolset)
+        logger.info(f"Connected to MCP Config JSON: {mcp_toolset}")
+    elif mcp_url:
+        if "sse" in mcp_url.lower():
+            server = MCPServerSSE(mcp_url)
+        else:
+            server = MCPServerStreamableHTTP(mcp_url)
+        master_toolsets.append(server)
+        logger.info(f"Connected to MCP Server: {mcp_url}")
+
+    if skills_directory and os.path.exists(skills_directory):
+        master_toolsets.append(SkillsToolset(directories=[str(skills_directory)]))
+
+    # Define Tag -> Prompt map
+    # Key is the MCP Tool Tag (or set of tags), Value is (SystemPrompt, AgentName)
+    agent_defs = {
+        "person": (CONTEXT_AGENT_PROMPT, "GitHub_Context_Agent"),
+        "workflow": (ACTIONS_AGENT_PROMPT, "GitHub_Actions_Agent"),
+        "codescan": (CODE_SECURITY_AGENT_PROMPT, "GitHub_Code_Security_Agent"),
+        "dependabot": (DEPENDABOT_AGENT_PROMPT, "GitHub_Dependabot_Agent"),
+        "comment-discussion": (DISCUSSIONS_AGENT_PROMPT, "GitHub_Discussions_Agent"),
+        "logo-gist": (GISTS_AGENT_PROMPT, "GitHub_Gists_Agent"),
+        "git-branch": (GIT_AGENT_PROMPT, "GitHub_Git_Agent"),
+        "issue-opened": (ISSUES_AGENT_PROMPT, "GitHub_Issues_Agent"),
+        "tag": (LABELS_AGENT_PROMPT, "GitHub_Labels_Agent"),
+        "bell": (NOTIFICATIONS_AGENT_PROMPT, "GitHub_Notifications_Agent"),
+        "organization": (ORGS_AGENT_PROMPT, "GitHub_Organizations_Agent"),
+        "project": (PROJECTS_AGENT_PROMPT, "GitHub_Projects_Agent"),
+        "git-pull-request": (PULL_REQUESTS_AGENT_PROMPT, "GitHub_Pull_Requests_Agent"),
+        "repo": (REPOS_AGENT_PROMPT, "GitHub_Repos_Agent"),
+        "shield-lock": (
+            SECRET_PROTECTION_AGENT_PROMPT,
+            "GitHub_Secret_Protection_Agent",
+        ),
+        "shield": (
+            SECURITY_ADVISORIES_AGENT_PROMPT,
+            "GitHub_Security_Advisories_Agent",
+        ),
+        "star": (STARGAZERS_AGENT_PROMPT, "GitHub_Stargazers_Agent"),
+        "people": (USERS_AGENT_PROMPT, "GitHub_Users_Agent"),
+        "copilot": (COPILOT_AGENT_PROMPT, "GitHub_Copilot_Agent"),
+        "copilot_spaces": (COPILOT_SPACES_AGENT_PROMPT, "GitHub_Copilot_Spaces_Agent"),
+        "github_support_docs_search": (
+            SUPPORT_DOCS_AGENT_PROMPT,
+            "GitHub_Support_Docs_Agent",
+        ),
+    }
+
+    child_agents = {}
+
+    for tag, (system_prompt, agent_name) in agent_defs.items():
+        tag_toolsets = []
+        for ts in master_toolsets:
+
+            def filter_func(ctx, tool_def, t=tag):
+                return tool_in_tag(tool_def, t)
+
+            if hasattr(ts, "filtered"):
+                filtered_ts = ts.filtered(filter_func)
+                tag_toolsets.append(filtered_ts)
+            else:
+                pass
+
+        agent = Agent(
+            name=agent_name,
+            system_prompt=system_prompt,
+            model=model,
+            model_settings=settings,
+            toolsets=tag_toolsets,
+            tool_timeout=DEFAULT_TOOL_TIMEOUT,
+        )
+        child_agents[tag] = agent
+
+    # Create Supervisor
+    supervisor = Agent(
+        name=AGENT_NAME,
+        system_prompt=SUPERVISOR_SYSTEM_PROMPT,
+        model=model,
+        model_settings=settings,
+        deps_type=Any,
+    )
+
+    # Define delegation tools
+    # We define these explicitly to give the Supervisor clear, typed tools.
+
+    @supervisor.tool
+    async def assign_task_to_context_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to user context and general GitHub status to the Context Agent."""
+        return (
+            await child_agents["person"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_actions_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to GitHub Actions and Workflows to the Actions Agent."""
+        return (
+            await child_agents["workflow"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_code_security_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to code security and scanning to the Code Security Agent."""
+        return (
+            await child_agents["codescan"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_dependabot_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Dependabot to the Dependabot Agent."""
+        return (
+            await child_agents["dependabot"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_discussions_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to GitHub Discussions to the Discussions Agent."""
+        return (
+            await child_agents["comment-discussion"].run(
+                task, usage=ctx.usage, deps=ctx.deps
+            )
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_gists_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Gists to the Gists Agent."""
+        return (
+            await child_agents["logo-gist"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_git_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to low-level Git operations (refs, blobs) to the Git Agent."""
+        return (
+            await child_agents["git-branch"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_issues_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Issues (create, list, comment) to the Issues Agent."""
+        return (
+            await child_agents["issue-opened"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_labels_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Labels to the Labels Agent."""
+        return (
+            await child_agents["tag"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_notifications_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to Notifications to the Notifications Agent."""
+        return (
+            await child_agents["bell"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_organizations_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to Organizations to the Organizations Agent."""
+        return (
+            await child_agents["organization"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_projects_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to GitHub Projects to the Projects Agent."""
+        return (
+            await child_agents["project"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_pull_requests_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to Pull Requests to the Pull Requests Agent."""
+        return (
+            await child_agents["git-pull-request"].run(
+                task, usage=ctx.usage, deps=ctx.deps
+            )
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_repos_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Repositories (list, settings, delete) to the Repositories Agent."""
+        return (
+            await child_agents["repo"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_secret_protection_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to Secret Protection to the Secret Protection Agent."""
+        return (
+            await child_agents["shield-lock"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_security_advisories_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to Security Advisories to the Security Advisories Agent."""
+        return (
+            await child_agents["shield"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_stargazers_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Stargazers to the Stargazers Agent."""
+        return (
+            await child_agents["star"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_users_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to Users to the Users Agent."""
+        return (
+            await child_agents["people"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_copilot_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task related to GitHub Copilot coding tasks to the Copilot Agent."""
+        return (
+            await child_agents["copilot"].run(task, usage=ctx.usage, deps=ctx.deps)
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_copilot_spaces_agent(
+        ctx: RunContext[Any], task: str
+    ) -> str:
+        """Assign a task related to Copilot Spaces to the Copilot Spaces Agent."""
+        return (
+            await child_agents["copilot_spaces"].run(
+                task, usage=ctx.usage, deps=ctx.deps
+            )
+        ).output
+
+    @supervisor.tool
+    async def assign_task_to_support_docs_agent(ctx: RunContext[Any], task: str) -> str:
+        """Assign a task to search GitHub Support Docs to the Support Docs Agent."""
+        return (
+            await child_agents["github_support_docs_search"].run(
+                task, usage=ctx.usage, deps=ctx.deps
+            )
+        ).output
+
+    return supervisor
+
+
+def create_agent_server(
+    provider: str = DEFAULT_PROVIDER,
+    model_id: str = DEFAULT_MODEL_ID,
+    base_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    mcp_url: str = DEFAULT_MCP_URL,
+    mcp_config: str = DEFAULT_MCP_CONFIG,
+    skills_directory: Optional[str] = DEFAULT_SKILLS_DIRECTORY,
+    debug: Optional[bool] = DEFAULT_DEBUG,
+    host: Optional[str] = DEFAULT_HOST,
+    port: Optional[int] = DEFAULT_PORT,
+    enable_web_ui: bool = DEFAULT_ENABLE_WEB_UI,
+):
+    print(
+        f"Starting {AGENT_NAME} with provider={provider}, model={model_id}, mcp={mcp_url} | {mcp_config}"
+    )
+    agent = create_agent(
+        provider=provider,
+        model_id=model_id,
+        base_url=base_url,
+        api_key=api_key,
+        mcp_url=mcp_url,
+        mcp_config=mcp_config,
+        skills_directory=skills_directory,
+    )
+
+    if skills_directory and os.path.exists(skills_directory):
+        skills = load_skills_from_directory(skills_directory)
+        logger.info(f"Loaded {len(skills)} skills from {skills_directory}")
+    else:
+        skills = [
+            Skill(
+                id="github_agent",
+                name="GitHub Agent",
+                description="General access to GitHub tools",
+                tags=["github"],
+                input_modes=["text"],
+                output_modes=["text"],
+            )
+        ]
+
+    a2a_app = agent.to_a2a(
+        name=AGENT_NAME,
+        description=AGENT_DESCRIPTION,
+        version=__version__,
+        skills=skills,
+        debug=debug,
+    )
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        if hasattr(a2a_app, "router"):
+            async with a2a_app.router.lifespan_context(a2a_app):
+                yield
+        else:
+            yield
+
+    app = FastAPI(
+        title=f"{AGENT_NAME} - A2A + AG-UI Server",
+        description=AGENT_DESCRIPTION,
+        debug=debug,
+        lifespan=lifespan,
+    )
+
+    @app.get("/health")
+    async def health_check():
+        return {"status": "OK"}
+
+    app.mount("/a2a", a2a_app)
+
+    @app.post("/ag-ui")
+    async def ag_ui_endpoint(request: Request) -> Response:
+        accept = request.headers.get("accept", SSE_CONTENT_TYPE)
+        try:
+            run_input = AGUIAdapter.build_run_input(await request.body())
+        except ValidationError as e:
+            return Response(
+                content=json.dumps(e.json()),
+                media_type="application/json",
+                status_code=422,
+            )
+
+        # Prune large messages from history
+        if hasattr(run_input, "messages"):
+            run_input.messages = prune_large_messages(run_input.messages)
+
+        adapter = AGUIAdapter(agent=agent, run_input=run_input, accept=accept)
+        event_stream = adapter.run_stream()
+        sse_stream = adapter.encode_stream(event_stream)
+
+        return StreamingResponse(
+            sse_stream,
+            media_type=accept,
+        )
+
+    if enable_web_ui:
+        web_ui = agent.to_web(instructions=SUPERVISOR_SYSTEM_PROMPT)
+        app.mount("/", web_ui)
+        logger.info(
+            "Starting server on %s:%s (A2A at /a2a, AG-UI at /ag-ui, Web UI: %s)",
+            host,
+            port,
+            "Enabled at /" if enable_web_ui else "Disabled",
+        )
+
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        timeout_keep_alive=1800,
+        timeout_graceful_shutdown=60,
+        log_level="debug" if debug else "info",
+    )
+
+
+def agent_server():
+    print(f"github_agent v{__version__}")
+    parser = argparse.ArgumentParser(
+        description=f"Run the {AGENT_NAME} A2A + AG-UI Server"
+    )
+    parser.add_argument(
+        "--host", default=DEFAULT_HOST, help="Host to bind the server to"
+    )
+    parser.add_argument(
+        "--port", type=int, default=DEFAULT_PORT, help="Port to bind the server to"
+    )
+    parser.add_argument("--debug", type=bool, default=DEFAULT_DEBUG, help="Debug mode")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+
+    parser.add_argument(
+        "--provider",
+        default=DEFAULT_PROVIDER,
+        choices=["openai", "anthropic", "google", "huggingface"],
+        help="LLM Provider",
+    )
+    parser.add_argument("--model-id", default=DEFAULT_MODEL_ID, help="LLM Model ID")
+    parser.add_argument(
+        "--base-url",
+        default=DEFAULT_OPENAI_BASE_URL,
+        help="LLM Base URL (for OpenAI compatible providers)",
+    )
+    parser.add_argument("--api-key", default=DEFAULT_OPENAI_API_KEY, help="LLM API Key")
+    parser.add_argument("--mcp-url", default=DEFAULT_MCP_URL, help="MCP Server URL")
+    parser.add_argument(
+        "--mcp-config", default=DEFAULT_MCP_CONFIG, help="MCP Server Config"
+    )
+    parser.add_argument(
+        "--skills-directory",
+        default=DEFAULT_SKILLS_DIRECTORY,
+        help="Directory containing agent skills",
+    )
+    parser.add_argument(
+        "--web",
+        action="store_true",
+        default=DEFAULT_ENABLE_WEB_UI,
+        help="Enable Pydantic AI Web UI",
+    )
+    args = parser.parse_args()
+
+    if args.debug:
+        for handler in logging.root.handlers[:]:
+            logging.root.removeHandler(handler)
+
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[logging.StreamHandler()],
+            force=True,
+        )
+        logging.getLogger("pydantic_ai").setLevel(logging.DEBUG)
+        logging.getLogger("fastmcp").setLevel(logging.DEBUG)
+        logging.getLogger("httpcore").setLevel(logging.DEBUG)
+        logging.getLogger("httpx").setLevel(logging.DEBUG)
+        logger.setLevel(logging.DEBUG)
+        logger.debug("Debug mode enabled")
+
+    create_agent_server(
+        provider=args.provider,
+        model_id=args.model_id,
+        base_url=args.base_url,
+        api_key=args.api_key,
+        mcp_url=args.mcp_url,
+        mcp_config=args.mcp_config,
+        skills_directory=args.skills_directory,
+        debug=args.debug,
+        host=args.host,
+        port=args.port,
+        enable_web_ui=args.web,
+    )
+
+
+if __name__ == "__main__":
+    agent_server()

github_agent/utils.py

@@ -0,0 +1,295 @@
+#!/usr/bin/python
+# coding: utf-8
+
+import os
+import pickle
+import yaml
+from pathlib import Path
+from typing import Any, Union, List, Optional
+import json
+from importlib.resources import files, as_file
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.models.google import GoogleModel
+from pydantic_ai.models.huggingface import HuggingFaceModel
+from pydantic_ai_skills import Skill
+
+
+def to_integer(string: Union[str, int] = None) -> int:
+    if isinstance(string, int):
+        return string
+    if not string:
+        return 0
+    try:
+        return int(string.strip())
+    except ValueError:
+        raise ValueError(f"Cannot convert '{string}' to integer")
+
+
+def to_boolean(string: Union[str, bool] = None) -> bool:
+    if isinstance(string, bool):
+        return string
+    if not string:
+        return False
+    normalized = str(string).strip().lower()
+    true_values = {"t", "true", "y", "yes", "1"}
+    false_values = {"f", "false", "n", "no", "0"}
+    if normalized in true_values:
+        return True
+    elif normalized in false_values:
+        return False
+    else:
+        raise ValueError(f"Cannot convert '{string}' to boolean")
+
+
+def to_float(string: Union[str, float] = None) -> float:
+    if isinstance(string, float):
+        return string
+    if not string:
+        return 0.0
+    try:
+        return float(string.strip())
+    except ValueError:
+        raise ValueError(f"Cannot convert '{string}' to float")
+
+
+def to_list(string: Union[str, list] = None) -> list:
+    if isinstance(string, list):
+        return string
+    if not string:
+        return []
+    try:
+        return json.loads(string)
+    except Exception:
+        return string.split(",")
+
+
+def to_dict(string: Union[str, dict] = None) -> dict:
+    if isinstance(string, dict):
+        return string
+    if not string:
+        return {}
+    try:
+        return json.loads(string)
+    except Exception:
+        raise ValueError(f"Cannot convert '{string}' to dict")
+
+
+def prune_large_messages(messages: list[Any], max_length: int = 5000) -> list[Any]:
+    """
+    Summarize large tool outputs in the message history to save context window.
+    Keeps the most recent tool outputs intact if they are the very last message,
+    but generally we want to prune history.
+    """
+    pruned_messages = []
+    for i, msg in enumerate(messages):
+        content = getattr(msg, "content", None)
+        if content is None and isinstance(msg, dict):
+            content = msg.get("content")
+
+        if isinstance(content, str) and len(content) > max_length:
+            summary = (
+                f"{content[:200]} ... "
+                f"[Output truncated, original length {len(content)} characters] "
+                f"... {content[-200:]}"
+            )
+
+            # Replace content
+            if isinstance(msg, dict):
+                msg["content"] = summary
+                pruned_messages.append(msg)
+            elif hasattr(msg, "content"):
+                # Try to create a copy or modify in place if mutable
+                # If it's a Pydantic model it might be immutable or require copy
+                try:
+                    # Attempt shallow copy with update
+                    from copy import copy
+
+                    new_msg = copy(msg)
+                    new_msg.content = summary
+                    pruned_messages.append(new_msg)
+                except Exception:
+                    # Fallback: keep original if we can't modify
+                    pruned_messages.append(msg)
+            else:
+                pruned_messages.append(msg)
+        else:
+            pruned_messages.append(msg)
+
+    return pruned_messages
+
+
+def save_model(model: Any, file_name: str = "model", file_path: str = ".") -> str:
+    pickle_file = os.path.join(file_path, f"{file_name}.pkl")
+    with open(pickle_file, "wb") as file:
+        pickle.dump(model, file)
+    return pickle_file
+
+
+def load_model(file: str) -> Any:
+    with open(file, "rb") as model_file:
+        model = pickle.load(model_file)
+    return model
+
+
+def retrieve_package_name() -> str:
+    """
+    Returns the top-level package name of the module that imported this utils.py.
+    """
+    if __package__:
+        top = __package__.partition(".")[0]
+        if top and top != "__main__":
+            return top
+
+    try:
+        file_path = Path(__file__).resolve()
+        for parent in file_path.parents:
+            if (
+                (parent / "pyproject.toml").is_file()
+                or (parent / "setup.py").is_file()
+                or (parent / "__init__.py").is_file()
+            ):
+                return parent.name
+    except Exception:
+        pass
+
+    return "unknown_package"
+
+
+def get_skills_path() -> str:
+    skills_dir = files(retrieve_package_name()) / "skills"
+    with as_file(skills_dir) as path:
+        skills_path = str(path)
+    return skills_path
+
+
+def get_mcp_config_path() -> str:
+    mcp_config_file = files(retrieve_package_name()) / "mcp_config.json"
+    with as_file(mcp_config_file) as path:
+        mcp_config_path = str(path)
+    return mcp_config_path
+
+
+def load_skills_from_directory(directory: str) -> List[Skill]:
+    skills = []
+    base_path = Path(directory)
+
+    if not base_path.exists():
+        print(f"Skills directory not found: {directory}")
+        return skills
+
+    for item in base_path.iterdir():
+        if item.is_dir():
+            skill_file = item / "SKILL.md"
+            if skill_file.exists():
+                try:
+                    with open(skill_file, "r") as f:
+                        # Extract frontmatter
+                        content = f.read()
+                        if content.startswith("---"):
+                            _, frontmatter, _ = content.split("---", 2)
+                            data = yaml.safe_load(frontmatter)
+
+                            skill_id = item.name
+                            skill_name = data.get("name", skill_id)
+                            skill_desc = data.get(
+                                "description", f"Access to {skill_name} tools"
+                            )
+                            skills.append(
+                                Skill(
+                                    id=skill_id,
+                                    name=skill_name,
+                                    description=skill_desc,
+                                    tags=[skill_id],
+                                    input_modes=["text"],
+                                    output_modes=["text"],
+                                )
+                            )
+                except Exception as e:
+                    print(f"Error loading skill from {skill_file}: {e}")
+
+    return skills
+
+
+def create_model(
+    provider: str,
+    model_id: str,
+    base_url: Optional[str],
+    api_key: Optional[str],
+):
+    if provider == "openai":
+        target_base_url = base_url
+        target_api_key = api_key
+        if target_base_url:
+            os.environ["OPENAI_BASE_URL"] = target_base_url
+        if target_api_key:
+            os.environ["OPENAI_API_KEY"] = target_api_key
+        return OpenAIChatModel(model_name=model_id, provider="openai")
+
+    elif provider == "anthropic":
+        if api_key:
+            os.environ["ANTHROPIC_API_KEY"] = api_key
+        return AnthropicModel(model_name=model_id)
+
+    elif provider == "google":
+        if api_key:
+            os.environ["GEMINI_API_KEY"] = api_key
+            os.environ["GOOGLE_API_KEY"] = api_key
+        return GoogleModel(model_name=model_id)
+
+    elif provider == "huggingface":
+        if api_key:
+            os.environ["HF_TOKEN"] = api_key
+        return HuggingFaceModel(model_name=model_id)
+    return OpenAIChatModel(model_name=model_id, provider="openai")
+
+
+def extract_tool_tags(tool_def: Any) -> List[str]:
+    """
+    Extracts tags from a tool definition object.
+    """
+    tags_list = []
+
+    meta = getattr(tool_def, "meta", None)
+    if isinstance(meta, dict):
+        fastmcp = meta.get("fastmcp") or meta.get("_fastmcp") or {}
+        tags_list = fastmcp.get("tags", [])
+        if tags_list:
+            return tags_list
+
+        tags_list = meta.get("tags", [])
+        if tags_list:
+            return tags_list
+
+    metadata = getattr(tool_def, "metadata", None)
+    if isinstance(metadata, dict):
+        tags_list = metadata.get("tags", [])
+        if tags_list:
+            return tags_list
+
+        meta_nested = metadata.get("meta") or {}
+        fastmcp = meta_nested.get("fastmcp") or meta_nested.get("_fastmcp") or {}
+        tags_list = fastmcp.get("tags", [])
+        if tags_list:
+            return tags_list
+
+        tags_list = meta_nested.get("tags", [])
+        if tags_list:
+            return tags_list
+
+    tags_list = getattr(tool_def, "tags", [])
+    if isinstance(tags_list, list) and tags_list:
+        return tags_list
+
+    return []
+
+
+def tool_in_tag(tool_def: Any, tag: str) -> bool:
+    """
+    Checks if a tool belongs to a specific tag.
+    """
+    tool_tags = extract_tool_tags(tool_def)
+    if tag in tool_tags:
+        return True
+    else:
+        return False

github_agent-0.1.1.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: github-agent
+Version: 0.1.1
+Summary: GitHub Agent for MCP
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: Public Domain
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic-ai-slim[a2a,ag-ui,anthropic,fastmcp,google,huggingface,openai,web]>=1.32.0
+Requires-Dist: pydantic-ai-skills
+Requires-Dist: fastapi>=0.128.0
+Requires-Dist: fastmcp
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Dynamic: license-file
+
+# GitHub Agent - A2A | AG-UI | MCP
+
+![PyPI - Version](https://img.shields.io/pypi/v/github-agent)
+![MCP Server](https://badge.mcpx.dev?type=server 'MCP Server')
+![PyPI - Downloads](https://img.shields.io/pypi/dd/github-agent)
+![GitHub Repo stars](https://img.shields.io/github/stars/Knuckles-Team/github-agent)
+![GitHub forks](https://img.shields.io/github/forks/Knuckles-Team/github-agent)
+![GitHub contributors](https://img.shields.io/github/contributors/Knuckles-Team/github-agent)
+![PyPI - License](https://img.shields.io/pypi/l/github-agent)
+![GitHub](https://img.shields.io/github/license/Knuckles-Team/github-agent)
+
+![GitHub last commit (by committer)](https://img.shields.io/github/last-commit/Knuckles-Team/github-agent)
+![GitHub pull requests](https://img.shields.io/github/issues-pr/Knuckles-Team/github-agent)
+![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/Knuckles-Team/github-agent)
+![GitHub issues](https://img.shields.io/github/issues/Knuckles-Team/github-agent)
+
+![GitHub top language](https://img.shields.io/github/languages/top/Knuckles-Team/github-agent)
+![GitHub language count](https://img.shields.io/github/languages/count/Knuckles-Team/github-agent)
+![GitHub repo size](https://img.shields.io/github/repo-size/Knuckles-Team/github-agent)
+![GitHub repo file count (file type)](https://img.shields.io/github/directory-file-count/Knuckles-Team/github-agent)
+![PyPI - Wheel](https://img.shields.io/pypi/wheel/github-agent)
+![PyPI - Implementation](https://img.shields.io/pypi/implementation/github-agent)
+
+*Version: 0.1.1*
+
+## Overview
+
+**GitHub Agent** is a powerful **Model Context Protocol (MCP)** server and **Agent-to-Agent (A2A)** system designed to interact with GitHub.
+
+It acts as a **Supervisor Agent**, delegating tasks to a suite of specialized **Child Agents**, each focused on a specific domain of the GitHub API (e.g., Issues, Pull Requests, Repositories, Actions). This architecture allows for precise and efficient handling of complex GitHub operations.
+
+This repository is actively maintained - Contributions are welcome!
+
+### Capabilities:
+- **Supervisor-Worker Architecture**: Orchestrates specialized agents for optimal task execution.
+- **Comprehensive GitHub Coverage**: specialized agents for Issues, PRs, Repos, Actions, Organizations, and more.
+- **MCP Support**: Fully compatible with the Model Context Protocol.
+- **A2A Integration**: Ready for Agent-to-Agent communication.
+- **Flexible Deployment**: Run via Docker, Docker Compose, or locally.
+
+## Architecture
+
+### System components
+
+```mermaid
+---
+config:
+  layout: dagre
+---
+flowchart TB
+ subgraph subGraph0["Agent Capabilities"]
+        Supervisor["Supervisor Agent"]
+        Server["A2A Server - Uvicorn/FastAPI"]
+        ChildAgents["Child Agents (Specialists)"]
+        MCP["GitHub MCP Tools"]
+  end
+    Supervisor --> ChildAgents
+    ChildAgents --> MCP
+    User["User Query"] --> Server
+    Server --> Supervisor
+    MCP --> GitHubAPI["GitHub API"]
+
+     Supervisor:::agent
+     ChildAgents:::agent
+     Server:::server
+     User:::server
+    classDef server fill:#f9f,stroke:#333
+    classDef agent fill:#bbf,stroke:#333,stroke-width:2px
+    style Server stroke:#000000,fill:#FFD600
+    style MCP stroke:#000000,fill:#BBDEFB
+    style GitHubAPI fill:#E6E6FA
+    style User fill:#C8E6C9
+    style subGraph0 fill:#FFF9C4
+```
+
+### Component Interaction
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Server as A2A Server
+    participant Supervisor as Supervisor Agent
+    participant Child as Child Agent (e.g. Issues)
+    participant MCP as GitHub MCP Tools
+    participant GitHub as GitHub API
+
+    User->>Server: "Create an issue in repo X"
+    Server->>Supervisor: Invoke Supervisor
+    Supervisor->>Supervisor: Analyze Request & Select Specialist
+    Supervisor->>Child: Delegate to Issues Agent
+    Child->>MCP: Call create_issue Tool
+    MCP->>GitHub: POST /repos/user/repo/issues
+    GitHub-->>MCP: Issue Created JSON
+    MCP-->>Child: Tool Response
+    Child-->>Supervisor: Task Complete
+    Supervisor-->>Server: Final Response
+    Server-->>User: "Issue #123 created successfully"
+```
+
+## Specialized Agents
+
+The Supervisor delegates tasks to these specialized agents:
+
+| Agent Name | Description |
+|:-----------|:------------|
+| `GitHub_Context_Agent` | Provides context about the current user and GitHub status. |
+| `GitHub_Actions_Agent` | Manages GitHub Actions workflows and runs. |
+| `GitHub_Code_Security_Agent` | Handles code security scanning and alerts. |
+| `GitHub_Dependabot_Agent` | Manages Dependabot alerts and configurations. |
+| `GitHub_Discussions_Agent` | Manages repository discussions. |
+| `GitHub_Gists_Agent` | Manages GitHub Gists. |
+| `GitHub_Git_Agent` | Performs low-level Git operations (refs, trees, blobs). |
+| `GitHub_Issues_Agent` | Manages Issues (create, list, update, comment). |
+| `GitHub_Labels_Agent` | Manages repository labels. |
+| `GitHub_Notifications_Agent` | Checks and manages notifications. |
+| `GitHub_Organizations_Agent` | Manages Organization memberships and settings. |
+| `GitHub_Projects_Agent` | Manages GitHub Projects (V2). |
+| `GitHub_Pull_Requests_Agent` | Manages Pull Requests (create, review, merge). |
+| `GitHub_Repos_Agent` | Manages Repositories (create, list, delete, settings). |
+| `GitHub_Secret_Protection_Agent` | Manages secret scanning protection. |
+| `GitHub_Security_Advisories_Agent` | Accesses security advisories. |
+| `GitHub_Stargazers_Agent` | Views repository stargazers. |
+| `GitHub_Users_Agent` | Accesses public user information. |
+| `GitHub_Copilot_Agent` | Assists with coding tasks via Copilot. |
+| `GitHub_Support_Docs_Agent` | Searches GitHub Support documentation. |
+
+## Usage
+
+### Prerequisites
+- Python 3.10+
+- A valid GitHub Personal Access Token (PAT) with appropriate permissions.
+
+### Installation
+
+```bash
+pip install github-agent
+```
+Or using UV:
+```bash
+uv pip install github-agent
+```
+
+### CLI
+
+The `github-agent` command starts the server.
+
+| Argument | Description | Default |
+|:---|:---|:---|
+| `--host` | Host to bind the server to | `0.0.0.0` |
+| `--port` | Port to bind the server to | `9000` |
+| `--mcp-config` | Path to MCP configuration file | `mcp_config.json` |
+| `--provider` | LLM Provider (openai, anthropic, google, etc.) | `openai` |
+| `--model-id` | LLM Model ID | `qwen/qwen3-4b-2507` |
+
+### Running the Agent Server
+
+```bash
+github-agent --provider openai --model-id gpt-4o --api-key sk-...
+```
+
+## Docker
+
+### Build
+
+```bash
+docker build -t github-agent .
+```
+
+### Run using Docker
+
+```bash
+docker run -d \
+  -p 9000:9000 \
+  -e OPENAI_API_KEY=sk-... \
+  -e MCP_CONFIG=/app/mcp_config.json \
+  knucklessg1/github-agent:latest
+```
+
+### Run using Docker Compose
+
+Create a `docker-compose.yml`:
+
+```yaml
+services:
+  github-agent:
+    image: knucklessg1/github-agent:latest
+    ports:
+      - "9000:9000"
+    environment:
+      - PROVIDER=openai
+      - MODEL_ID=gpt-4o
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+    volumes:
+      - ./mcp_config.json:/app/mcp_config.json
+```
+
+Then run:
+```bash
+docker-compose up -d
+```
+
+## Repository Owners
+
+<img width="100%" height="180em" src="https://github-readme-stats.vercel.app/api?username=Knucklessg1&show_icons=true&hide_border=true&&count_private=true&include_all_commits=true" />
+
+![GitHub followers](https://img.shields.io/github/followers/Knucklessg1)
+![GitHub User's stars](https://img.shields.io/github/stars/Knucklessg1)

github_agent-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+github_agent/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+github_agent/github_agent.py,sha256=eb_j0zEtUMud7sXAh3uQNOU87Y5dRtJoejknnhUk4vg,26033
+github_agent/utils.py,sha256=ruOgtdRLF2or1dsPNzl6Fe9iCVZncYyeIUsaePPOd0U,9135
+github_agent-0.1.1.dist-info/licenses/LICENSE,sha256=5ALbh4fIALWVsUhO7q1nFT1bQb-CL9sWKf7p3GgLEG8,1070
+github_agent-0.1.1.dist-info/METADATA,sha256=pETHU4C74fQm_u_E0gla9WhnlJm-YeyeLfG_arLExPU,8168
+github_agent-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+github_agent-0.1.1.dist-info/entry_points.txt,sha256=PBPcmYlKzTvAtDxta6Vc681dQpFYFmoih1KZCwm_To4,72
+github_agent-0.1.1.dist-info/top_level.txt,sha256=LpuUcrgMgA5o3phSpQjW0OJ7b2GpHuFQiCqxLfeu2c8,13
+github_agent-0.1.1.dist-info/RECORD,,

github_agent-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

github_agent-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+github-agent = github_agent.github_agent:agent_server

github_agent-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Knuckles Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

github_agent-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+github_agent