github-mcp-agent 0.1.0__py3-none-any.whl

github_mcp_agent/agent.py

@@ -0,0 +1,103 @@
+import os
+from contextlib import contextmanager
+from pathlib import Path
+
+from dotenv import load_dotenv
+from strands import Agent
+from strands.tools.mcp.mcp_client import MCPClient
+from mcp import StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from github_mcp_agent.tools import detect_current_repo, local_tools
+from github_mcp_agent import providers
+
+
+_config_dir = Path.home() / ".config" / "github-mcp-agent"
+load_dotenv(_config_dir / ".env")
+load_dotenv()
+
+MODEL_ID = os.getenv("MODEL_ID", "us.anthropic.claude-haiku-4-5-20251001-v1:0")
+PROVIDER = os.getenv("PROVIDER", "bedrock")
+VERBOSE = os.getenv("VERBOSE", "").lower() in ("1", "true", "yes")
+
+
+def _load_system_prompt() -> tuple[str, str | None]:
+    custom = _config_dir / "system_prompt.txt"
+    if custom.exists():
+        prompt = custom.read_text()
+    else:
+        from importlib.resources import files
+        prompt = files("github_mcp_agent").joinpath("system_prompt.txt").read_text()
+
+    repo = detect_current_repo()
+    if repo != "No GitHub remote detected":
+        prompt += f"\n\nThe user is currently working in the GitHub repository: {repo}. Default to this repository for all actions unless the user explicitly specifies another."
+        return prompt, repo
+    return prompt, None
+
+
+def _make_verbose_callback(provider: str):
+    import json as _json
+    is_ollama = provider == "ollama"
+
+    def callback(**kwargs):
+        if "current_tool_use" in kwargs:
+            tool = kwargs["current_tool_use"]
+            if tool.get("name"):
+                print(f"\n  \033[2;36m> {tool['name']}\033[0m", flush=True)
+        if "data" in kwargs:
+            text = kwargs["data"]
+            if is_ollama:
+                try:
+                    parsed = _json.loads(text)
+                    if isinstance(parsed, dict) and "text" in parsed:
+                        text = parsed["text"]
+                except Exception:
+                    pass
+            print(text, end="", flush=True)
+
+    return callback
+
+
+@contextmanager
+def create_agent(provider=None, model_id=None, verbose=False):
+    _provider = provider or PROVIDER
+    _model_id = model_id or MODEL_ID
+
+    token = os.environ.get("GITHUB_TOKEN")
+    if not token:
+        raise RuntimeError(
+            "GITHUB_TOKEN is not set. Run 'github-agent setup' to configure."
+        )
+
+    mcp_client = MCPClient(
+        lambda: stdio_client(
+            StdioServerParameters(
+                command="docker",
+                args=[
+                    "run", "-i", "--rm",
+                    "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
+                    "ghcr.io/github/github-mcp-server",
+                    "stdio",
+                    "--toolsets", "all",
+                    "--log-file", "/dev/null",
+                ],
+                env={"GITHUB_PERSONAL_ACCESS_TOKEN": token},
+            )
+        )
+    )
+
+    model = providers.build_model(_provider, _model_id)
+    system_prompt, current_repo = _load_system_prompt()
+
+    with mcp_client:
+        mcp_tools = mcp_client.list_tools_sync()
+        agent_kwargs = dict(model=model, tools=mcp_tools + local_tools, system_prompt=system_prompt)
+        if verbose or VERBOSE:
+            agent_kwargs["callback_handler"] = _make_verbose_callback(_provider)
+        else:
+            cb = providers.make_callback(_provider)
+            if cb:
+                agent_kwargs["callback_handler"] = cb
+        agent = Agent(**agent_kwargs)
+        yield agent, current_repo, len(mcp_tools) + len(local_tools)

github_mcp_agent/cli.py

@@ -0,0 +1,184 @@
+import os
+import readline
+import select
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+import questionary
+from rich.console import Console
+from rich.rule import Rule
+from rich.text import Text
+
+console = Console()
+
+CONFIG_DIR = Path.home() / ".config" / "github-mcp-agent"
+
+_PROVIDER_CHOICES = [
+    "AWS Bedrock", "Anthropic API", "OpenAI", "Google Gemini", "GitHub Copilot", "Local (Ollama)"
+]
+_PROVIDER_KEY = {
+    "AWS Bedrock": "bedrock",
+    "Anthropic API": "anthropic",
+    "OpenAI": "openai",
+    "Google Gemini": "gemini",
+    "GitHub Copilot": "copilot",
+    "Local (Ollama)": "ollama",
+}
+
+
+def _pick_model_for_provider(provider: str, _ask) -> tuple[str, str]:
+    import github_mcp_agent.providers as pkg
+    mod = getattr(pkg, provider)
+    console.print(f"  [dim]Provider: {provider}  (to switch, run: github-agent provider)[/dim]")
+    if provider == "ollama":
+        model_id = mod.pick_model(_ask)
+    else:
+        model_choices = [f"{name}  ({desc})" for _, name, desc in mod.MODELS]
+        model_display = _ask(questionary.select, "Model:", choices=model_choices)
+        model_id = mod.MODELS[model_choices.index(model_display)][0]
+    return provider, model_id
+
+
+def _run_agent(verbose: bool = False):
+    from github_mcp_agent.agent import MODEL_ID, PROVIDER, create_agent
+    try:
+        with create_agent(verbose=verbose) as (agent, current_repo, total_tools):
+            console.print()
+            console.print(Rule("[bold green]GitHub MCP Agent[/bold green]"))
+            repo_label = f"[bold]{current_repo}[/bold]" if current_repo else "[dim]none detected[/dim]"
+            console.print(f"  [dim]Loaded [bold]{total_tools}[/bold] tools  |  Repo: {repo_label}  |  Provider: [bold]{PROVIDER}[/bold]  |  Model: [bold]{MODEL_ID}[/bold]  |  Type 'exit' to quit[/dim]")
+            console.print(Rule())
+            console.print()
+
+            while True:
+                try:
+                    user_input = input("\033[1;36m You > \033[0m")
+                    while select.select([sys.stdin], [], [], 0.05)[0]:
+                        user_input += "\n" + sys.stdin.readline().rstrip("\n")
+                except (KeyboardInterrupt, EOFError):
+                    break
+
+                if not user_input.strip():
+                    continue
+                if user_input.strip().lower() in ["exit", "quit"]:
+                    break
+
+                console.print()
+                console.print(Text(" Agent", style="bold magenta"))
+                console.print()
+
+                try:
+                    agent(user_input)
+                except Exception as e:
+                    console.print(f"[bold red]Error:[/bold red] {e}")
+
+                console.print()
+
+            console.print()
+            console.print(Rule("[dim]Session ended[/dim]"))
+            console.print()
+
+    except RuntimeError as e:
+        console.print(f"\n[bold red]{e}[/bold red]\n")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"\n[bold red]Failed to start:[/bold red] {e}\n")
+        sys.exit(1)
+
+
+def _open_config():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    config_file = CONFIG_DIR / ".env"
+    if not config_file.exists():
+        config_file.write_text(
+            "GITHUB_TOKEN=\nAWS_PROFILE=default\nAWS_REGION=us-east-1\nMODEL_ID=us.anthropic.claude-haiku-4-5-20251001-v1:0\n"
+        )
+    editor = os.environ.get("EDITOR", "nano")
+    subprocess.run([editor, str(config_file)])
+
+
+def _open_prompt():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    prompt_file = CONFIG_DIR / "system_prompt.txt"
+    if not prompt_file.exists():
+        from importlib.resources import files
+        default = files("github_mcp_agent").joinpath("system_prompt.txt").read_text()
+        prompt_file.write_text(default)
+        console.print(f"  [dim]Created {prompt_file} with default prompt - edit to customize.[/dim]\n")
+    editor = os.environ.get("EDITOR", "nano")
+    subprocess.run([editor, str(prompt_file)])
+
+
+@click.group(invoke_without_command=True, context_settings={"help_option_names": ["-h", "--help"]})
+@click.option("--verbose", "-v", is_flag=True, default=False, help="Print tool calls as they happen")
+@click.pass_context
+def cli(ctx, verbose):
+    """GitHub MCP Agent - talk to your repos in plain English."""
+    if ctx.invoked_subcommand is None:
+        _run_agent(verbose=verbose)
+
+
+@cli.command()
+def setup():
+    """Run the interactive setup wizard."""
+    from github_mcp_agent.setup_wizard import run
+    run()
+
+
+@cli.command(name="provider")
+def switch_provider():
+    """Switch AI provider - pick credentials + model and save to config."""
+    from github_mcp_agent.setup_wizard import _ask, _write_config
+    from github_mcp_agent import providers as _providers
+    provider_display = _ask(questionary.select, "Provider:", choices=_PROVIDER_CHOICES)
+    provider_key = _PROVIDER_KEY[provider_display]
+    provider_values = _providers.setup(provider_key, _ask)
+    _write_config({"PROVIDER": provider_key, **provider_values})
+    console.print("  [green]Saved.[/green]")
+
+
+@cli.command(name="model")
+def switch_model():
+    """Pick a model for the current provider and save to config."""
+    from github_mcp_agent.agent import PROVIDER
+    from github_mcp_agent.setup_wizard import _ask, _write_config
+    _, effective_model = _pick_model_for_provider(PROVIDER, _ask)
+    _write_config({"MODEL_ID": effective_model})
+    console.print(f"  [green]Saved:[/green] model={effective_model}")
+
+
+@cli.command()
+def token():
+    """Update your GitHub Personal Access Token."""
+    from github_mcp_agent.setup_wizard import _ask, _validate_github_token, _write_config
+    new_token = _ask(questionary.password, "GitHub Personal Access Token:")
+    console.print("  Validating...", end=" ")
+    if _validate_github_token(new_token):
+        console.print("[green]valid[/green]")
+        _write_config({"GITHUB_TOKEN": new_token})
+        console.print("  [green]Saved.[/green]")
+    else:
+        console.print("[red]invalid - check the token and scopes[/red]")
+        sys.exit(1)
+
+
+@cli.command()
+def config():
+    """Open the config file in $EDITOR."""
+    _open_config()
+
+
+@cli.command()
+def prompt():
+    """Open the system prompt file in $EDITOR."""
+    _open_prompt()
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

github_mcp_agent/providers/__init__.py

@@ -0,0 +1,32 @@
+from . import anthropic, bedrock, copilot, gemini, ollama, openai
+
+
+_REGISTRY = {
+    "bedrock": bedrock,
+    "anthropic": anthropic,
+    "openai": openai,
+    "gemini": gemini,
+    "copilot": copilot,
+    "ollama": ollama,
+}
+
+
+def build_model(provider: str, model_id: str):
+    mod = _REGISTRY.get(provider)
+    if mod is None:
+        raise RuntimeError(f"Unknown provider: {provider}")
+    return mod.build_model(model_id)
+
+
+def make_callback(provider: str):
+    if provider == "ollama":
+        return ollama.make_callback()
+    return None
+
+
+def setup(provider: str, _ask) -> dict:
+    mod = _REGISTRY.get(provider)
+    if mod is None:
+        raise RuntimeError(f"Unknown provider: {provider}")
+    return mod.setup(_ask)
+pypi-AgEIcHlwaS5vcmcCJGU0ZDI1YWQ5LTEyOGMtNDUyZi1iNmZkLTEzOWU0MmRkNDIzOAACKlszLCJjZTAzNzUyYy00ZjNhLTQ3MTYtYjM2ZS02YmY0ZGNhZjkyMDciXQAABiD04xa6bIcHRFlnmMHzKPunpg81Z6OhNO_P102kWxtY9g

github_mcp_agent/providers/anthropic.py

@@ -0,0 +1,28 @@
+import os
+
+import questionary
+
+MODELS = [
+    ("claude-haiku-4-5-20251001", "claude-haiku-4-5", "fastest"),
+    ("claude-sonnet-4-6", "claude-sonnet-4-6", "balanced"),
+    ("claude-opus-4-7", "claude-opus-4-7", "most capable"),
+]
+
+
+def build_model(model_id: str):
+    from strands.models.anthropic import AnthropicModel
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        raise RuntimeError("ANTHROPIC_API_KEY is not set. Run 'github-agent setup' to configure.")
+    return AnthropicModel(model_id=model_id, max_tokens=8096)
+
+
+def setup(_ask) -> dict:
+    from rich.console import Console
+    Console().print("  [dim]Get your key at: console.anthropic.com/settings/keys[/dim]")
+    key = _ask(questionary.password, "Anthropic API key (sk-ant-...):")
+    model_choices = [f"{name}  ({desc})" for _, name, desc in MODELS]
+    model_display = _ask(questionary.select, "Model:", choices=model_choices)
+    return {
+        "ANTHROPIC_API_KEY": key,
+        "MODEL_ID": MODELS[model_choices.index(model_display)][0],
+    }

github_mcp_agent/providers/bedrock.py

@@ -0,0 +1,112 @@
+import os
+import subprocess
+from pathlib import Path
+
+import questionary
+
+REGIONS = [
+    ("us-east-1", "N. Virginia - recommended"),
+    ("us-west-2", "Oregon"),
+    ("eu-west-1", "Ireland"),
+    ("eu-central-1", "Frankfurt"),
+    ("eu-west-3", "Paris"),
+    ("ap-northeast-1", "Tokyo"),
+    ("ap-southeast-1", "Singapore"),
+    ("ap-southeast-2", "Sydney"),
+    ("ca-central-1", "Canada"),
+    ("sa-east-1", "Sao Paulo"),
+]
+
+MODELS = [
+    ("us.anthropic.claude-haiku-4-5-20251001-v1:0", "claude-haiku-4-5", "fastest, cheapest"),
+    ("us.anthropic.claude-sonnet-4-6", "claude-sonnet-4-6", "balanced"),
+    ("us.anthropic.claude-opus-4-7", "claude-opus-4-7", "most capable"),
+]
+
+
+def build_model(model_id: str):
+    from strands.models import BedrockModel
+    return BedrockModel(model_id=model_id, region_name=os.getenv("AWS_REGION", "us-east-1"))
+
+
+def _list_aws_profiles() -> list[str]:
+    profiles = []
+    for f in [Path.home() / ".aws" / "credentials", Path.home() / ".aws" / "config"]:
+        if f.exists():
+            for line in f.read_text().splitlines():
+                if line.startswith("[") and line.endswith("]"):
+                    name = line[1:-1].replace("profile ", "")
+                    if name not in profiles:
+                        profiles.append(name)
+    return profiles
+
+
+def _validate_aws_profile(profile: str) -> bool:
+    env = os.environ.copy()
+    env["AWS_PROFILE"] = profile
+    return subprocess.run(["aws", "sts", "get-caller-identity"], capture_output=True, env=env).returncode == 0
+
+
+def setup(_ask) -> dict:
+    values = {}
+
+    while True:
+        cred_method = _ask(
+            questionary.select,
+            "AWS credentials:",
+            choices=["Use existing profile", "Enter access keys directly", "AWS SSO / browser login"],
+        )
+
+        if cred_method == "Use existing profile":
+            profiles = _list_aws_profiles()
+            choices = profiles + ["other (type manually)"] if profiles else ["other (type manually)"]
+            choice = _ask(questionary.select, "AWS profile:", choices=choices)
+            if choice == "other (type manually)":
+                profile = _ask(questionary.text, "Profile name:", default="default")
+            else:
+                profile = choice
+            from rich.console import Console
+            Console().print("  Validating...", end=" ")
+            if _validate_aws_profile(profile):
+                Console().print("[green]valid[/green]")
+                values["AWS_PROFILE"] = profile
+                break
+            else:
+                Console().print("[red]invalid - check your AWS credentials[/red]")
+
+        elif cred_method == "Enter access keys directly":
+            values["AWS_ACCESS_KEY_ID"] = _ask(questionary.text, "AWS Access Key ID:")
+            values["AWS_SECRET_ACCESS_KEY"] = _ask(questionary.password, "AWS Secret Access Key:")
+            session_token = _ask(questionary.text, "AWS Session Token (leave blank if none):")
+            if session_token:
+                values["AWS_SESSION_TOKEN"] = session_token
+            break
+
+        elif cred_method == "AWS SSO / browser login":
+            profiles = _list_aws_profiles()
+            choices = profiles + ["other (type manually)"] if profiles else ["other (type manually)"]
+            choice = _ask(questionary.select, "SSO profile to use:", choices=choices)
+            if choice == "other (type manually)":
+                profile = _ask(questionary.text, "Profile name:")
+            else:
+                profile = choice
+            from rich.console import Console
+            console = Console()
+            console.print(f"\n  Running [bold]aws sso login --profile {profile}[/bold]")
+            result = subprocess.run(["aws", "sso", "login", "--profile", profile])
+            if result.returncode == 0:
+                values["AWS_PROFILE"] = profile
+                break
+            console.print("[red]SSO login failed - profile may not be configured for SSO.[/red]")
+            console.print("[dim]  Run: aws configure sso --profile <name>[/dim]")
+            console.print("[dim]  Or pick a different credential method below.[/dim]\n")
+
+    region_choices = [f"{r}  ({label})" for r, label in REGIONS]
+    region_display = _ask(questionary.select, "AWS Region:", choices=region_choices)
+    values["AWS_REGION"] = region_display.split()[0]
+
+    model_choices = [f"{name}  ({desc})  ->  {mid}" for mid, name, desc in MODELS]
+    model_display = _ask(questionary.select, "Model:", choices=model_choices)
+    values["MODEL_ID"] = MODELS[model_choices.index(model_display)][0]
+
+    return values

github_mcp_agent/providers/copilot.py

@@ -0,0 +1,32 @@
+import os
+
+import questionary
+
+MODELS = [
+    ("gpt-4o", "gpt-4o", "flagship"),
+    ("gpt-4o-mini", "gpt-4o-mini", "fast, cheap"),
+    ("claude-sonnet-4-5", "claude-sonnet-4-5", "Anthropic via Copilot"),
+    ("o3-mini", "o3-mini", "reasoning"),
+    ("gemini-1.5-pro", "gemini-1.5-pro", "Google via Copilot"),
+]
+
+
+def build_model(model_id: str):
+    from strands.models.litellm import LiteLLMModel
+    token = os.environ.get("GITHUB_TOKEN")
+    if not token:
+        raise RuntimeError("GITHUB_TOKEN is not set. Run 'github-agent setup' to configure.")
+    return LiteLLMModel(
+        model_id=f"openai/{model_id}",
+        params={"api_base": "https://api.githubcopilot.com", "api_key": token},
+    )
+
+
+def setup(_ask) -> dict:
+    from rich.console import Console
+    console = Console()
+    console.print("  [dim]Uses your GitHub token - no extra API key needed.[/dim]")
+    console.print("  [dim]Requires an active Copilot subscription (student pack, individual, or business).[/dim]")
+    model_choices = [f"{name}  ({desc})" for _, name, desc in MODELS]
+    model_display = _ask(questionary.select, "Model:", choices=model_choices)
+    return {"MODEL_ID": MODELS[model_choices.index(model_display)][0]}

github_mcp_agent/providers/gemini.py

@@ -0,0 +1,28 @@
+import os
+
+import questionary
+
+MODELS = [
+    ("gemini-2.0-flash", "gemini-2.0-flash", "fast, recommended"),
+    ("gemini-1.5-pro", "gemini-1.5-pro", "most capable"),
+    ("gemini-1.5-flash", "gemini-1.5-flash", "fast"),
+]
+
+
+def build_model(model_id: str):
+    from strands.models.litellm import LiteLLMModel
+    if not os.environ.get("GEMINI_API_KEY"):
+        raise RuntimeError("GEMINI_API_KEY is not set. Run 'github-agent setup' to configure.")
+    return LiteLLMModel(model_id=f"gemini/{model_id}")
+
+
+def setup(_ask) -> dict:
+    from rich.console import Console
+    Console().print("  [dim]Get your key at: aistudio.google.com/apikey[/dim]")
+    key = _ask(questionary.password, "Google AI Studio API key:")
+    model_choices = [f"{name}  ({desc})" for _, name, desc in MODELS]
+    model_display = _ask(questionary.select, "Model:", choices=model_choices)
+    return {
+        "GEMINI_API_KEY": key,
+        "MODEL_ID": MODELS[model_choices.index(model_display)][0],
+    }

github_mcp_agent/providers/ollama.py

@@ -0,0 +1,81 @@
+import os
+import subprocess
+
+import questionary
+
+POPULAR_MODELS = [
+    "llama3.2",
+    "llama3.1",
+    "mistral",
+    "gemma2",
+    "phi3",
+    "codellama",
+    "deepseek-r1",
+]
+
+
+def build_model(model_id: str):
+    from strands.models.litellm import LiteLLMModel
+    base_url = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
+    return LiteLLMModel(model_id=f"ollama/{model_id}", params={"api_base": base_url})
+
+
+def make_callback():
+    import json as _json
+
+    def callback(**kwargs):
+        if "data" in kwargs:
+            text = kwargs["data"]
+            try:
+                parsed = _json.loads(text)
+                if isinstance(parsed, dict) and "text" in parsed:
+                    text = parsed["text"]
+            except Exception:
+                pass
+            print(text, end="", flush=True)
+
+    return callback
+
+
+def pick_model(_ask) -> str:
+    result = subprocess.run(["ollama", "list"], capture_output=True, text=True)
+    installed = [line.split()[0] for line in result.stdout.splitlines()[1:] if line.split()]
+    choices = (installed if installed else POPULAR_MODELS) + ["other (type manually)"]
+    choice = _ask(questionary.select, "Model:", choices=choices)
+    if choice == "other (type manually)":
+        return _ask(questionary.text, "Model name:")
+    return choice
+
+
+def setup(_ask) -> dict:
+    from rich.console import Console
+    console = Console()
+
+    result = subprocess.run(["ollama", "list"], capture_output=True, text=True)
+    installed = []
+    if result.returncode == 0:
+        for line in result.stdout.splitlines()[1:]:
+            parts = line.split()
+            if parts:
+                installed.append(parts[0])
+
+    if installed:
+        choices = installed + ["other (type manually)"]
+        choice = _ask(questionary.select, "Model:", choices=choices)
+        if choice == "other (type manually)":
+            model = _ask(questionary.text, "Model name (e.g. llama3.2):")
+        else:
+            model = choice
+    else:
+        console.print("  [dim]No models installed yet. Pick one to pull:[/dim]")
+        choices = POPULAR_MODELS + ["other (type manually)"]
+        choice = _ask(questionary.select, "Model:", choices=choices)
+        if choice == "other (type manually)":
+            model = _ask(questionary.text, "Model name:")
+        else:
+            model = choice
+        console.print(f"\n  Running [bold]ollama pull {model}[/bold]")
+        subprocess.run(["ollama", "pull", model])
+
+    base_url = _ask(questionary.text, "Ollama base URL:", default="http://localhost:11434")
+    return {"MODEL_ID": model, "OLLAMA_BASE_URL": base_url}

github_mcp_agent/providers/openai.py

@@ -0,0 +1,28 @@
+import os
+
+import questionary
+
+MODELS = [
+    ("gpt-4o-mini", "gpt-4o-mini", "fast, cheap"),
+    ("gpt-4o", "gpt-4o", "flagship"),
+    ("gpt-4-turbo", "gpt-4-turbo", "legacy"),
+]
+
+
+def build_model(model_id: str):
+    from strands.models.litellm import LiteLLMModel
+    if not os.environ.get("OPENAI_API_KEY"):
+        raise RuntimeError("OPENAI_API_KEY is not set. Run 'github-agent setup' to configure.")
+    return LiteLLMModel(model_id=f"openai/{model_id}")
+
+
+def setup(_ask) -> dict:
+    from rich.console import Console
+    Console().print("  [dim]Get your key at: platform.openai.com/api-keys[/dim]")
+    key = _ask(questionary.password, "OpenAI API key (sk-...):")
+    model_choices = [f"{name}  ({desc})" for _, name, desc in MODELS]
+    model_display = _ask(questionary.select, "Model:", choices=model_choices)
+    return {
+        "OPENAI_API_KEY": key,
+        "MODEL_ID": MODELS[model_choices.index(model_display)][0],
+    }

github_mcp_agent/setup_wizard.py

@@ -0,0 +1,134 @@
+import subprocess
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+from rich.rule import Rule
+
+from github_mcp_agent import providers
+
+console = Console()
+CONFIG_DIR = Path.home() / ".config" / "github-mcp-agent"
+CONFIG_FILE = CONFIG_DIR / ".env"
+
+
+def _check(label: str, ok: bool, hint: str = ""):
+    if ok:
+        console.print(f"  [green]OK[/green]  {label}")
+    else:
+        console.print(f"  [red]FAIL[/red] {label}" + (f" - {hint}" if hint else ""))
+    return ok
+
+
+def _check_prerequisites(provider: str = "bedrock") -> bool:
+    console.print("\n[bold]Checking prerequisites...[/bold]")
+    ok = True
+    py = sys.version_info >= (3, 10)
+    ok &= _check("Python >= 3.10", py, f"found {sys.version.split()[0]}")
+    docker = subprocess.run(["docker", "info"], capture_output=True).returncode == 0
+    ok &= _check("Docker installed and running", docker, "install Docker from docker.com")
+    if provider == "bedrock":
+        aws = subprocess.run(["aws", "--version"], capture_output=True).returncode == 0
+        ok &= _check("AWS CLI installed", aws, "install from aws.amazon.com/cli")
+    if provider == "ollama":
+        ollama_ok = subprocess.run(["ollama", "list"], capture_output=True).returncode == 0
+        ok &= _check("Ollama installed and running", ollama_ok, "install from ollama.com then run: ollama serve")
+    return ok
+
+
+def _ask(fn, *args, **kwargs):
+    try:
+        val = fn(*args, **kwargs).ask()
+    except (KeyboardInterrupt, EOFError):
+        console.print("\n[yellow]Setup cancelled.[/yellow]")
+        sys.exit(0)
+    if val is None:
+        console.print("\n[yellow]Setup cancelled.[/yellow]")
+        sys.exit(0)
+    return val
+
+
+def _validate_github_token(token: str) -> bool:
+    req = urllib.request.Request("https://api.github.com/user")
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("User-Agent", "github-mcp-agent")
+    try:
+        with urllib.request.urlopen(req) as r:
+            return r.status == 200
+    except urllib.error.HTTPError:
+        return False
+
+
+def _pull_docker_image():
+    console.print("\n[bold]Pulling GitHub MCP Docker image...[/bold]")
+    subprocess.run(["docker", "pull", "ghcr.io/github/github-mcp-server"], check=False)
+
+
+def _write_config(values: dict):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    existing = {}
+    if CONFIG_FILE.exists():
+        for line in CONFIG_FILE.read_text().splitlines():
+            if "=" in line and not line.startswith("#"):
+                k, _, v = line.partition("=")
+                existing[k.strip()] = v.strip()
+    existing.update({k: v for k, v in values.items() if v})
+    lines = [f"{k}={v}" for k, v in existing.items()]
+    CONFIG_FILE.write_text("\n".join(lines) + "\n")
+
+
+def run():
+    console.print()
+    console.print(Rule("[bold green]GitHub MCP Agent - Setup[/bold green]"))
+
+    console.print()
+    console.print("  [dim]Create a token at: github.com/settings/tokens[/dim]")
+    console.print("  [dim]Required scopes: repo, read:org, project[/dim]")
+    token = _ask(questionary.password, "GitHub Personal Access Token:")
+    if token:
+        console.print("  Validating...", end=" ")
+        if _validate_github_token(token):
+            console.print("[green]valid[/green]")
+        else:
+            console.print("[red]invalid - check the token and scopes[/red]")
+            sys.exit(1)
+
+    console.print()
+
+    provider_display = _ask(
+        questionary.select,
+        "AI provider:",
+        choices=["AWS Bedrock", "Anthropic API", "OpenAI", "Google Gemini", "GitHub Copilot", "Local (Ollama)"],
+    )
+
+    provider_key = {
+        "AWS Bedrock": "bedrock",
+        "Anthropic API": "anthropic",
+        "OpenAI": "openai",
+        "Google Gemini": "gemini",
+        "GitHub Copilot": "copilot",
+        "Local (Ollama)": "ollama",
+    }[provider_display]
+
+    if not _check_prerequisites(provider=provider_key):
+        console.print("\n[red]Fix the issues above before continuing.[/red]")
+        sys.exit(1)
+
+    console.print()
+
+    provider_values = providers.setup(provider_key, _ask)
+
+    _write_config({"GITHUB_TOKEN": token, "PROVIDER": provider_key, **provider_values})
+    console.print(f"\n  [dim]Config saved to {CONFIG_FILE}[/dim]")
+
+    _pull_docker_image()
+
+    console.print()
+    console.print(Rule("[bold green]Setup complete[/bold green]"))
+    console.print()
+    console.print("  Run [bold cyan]github-agent[/bold cyan] to start.")
+    console.print("  Run [bold cyan]github-agent prompt[/bold cyan] to customize the system prompt.")
+    console.print()

github_mcp_agent/system_prompt.txt

@@ -0,0 +1,57 @@
+You are a GitHub project management assistant with full access to GitHub tools.
+
+When a user asks about a repository, user, issue, PR, or anything GitHub-related, ALWAYS use your tools to look it up. Never say you don't have access or ask the user to provide information you can find yourself.
+
+You also have two local file tools: read_local_file and list_local_files. Use these to read files directly from the user's local repo (e.g. TODO.md, README, config files) without going through the GitHub API.
+
+Examples of proactive tool use:
+- "what issues are open?" -> search for issues using the tools, do not ask which repo
+- "summarize this repo" -> fetch the repo, read files, list issues and PRs
+- "who contributed most?" -> look it up via the API
+- If the user mentions a repo name or username, use it immediately without asking for clarification
+- If a name search fails, try variations: different casing, hyphens vs underscores, with/without year suffixes, abbreviated names. Try at least 3-4 variations before giving up.
+- If an org name is ambiguous, search for the org by keyword using search tools before asking the user.
+
+Terminology - understand the difference:
+- "GitHub Project" or "project board" = a kanban-style board for organizing issues and tasks (GitHub Projects v2). Use project-related tools to create and manage these.
+- "repository" or "repo" = a codebase. Do NOT create a repository when the user asks for a "project board".
+- When the user says "create a project", "create a github project", "project board", or "add issues to a project" they mean GitHub Projects, not a new repository.
+
+GitHub Projects - field workflow:
+- Fields like Status, Priority, Size, Estimate, and Iteration already exist on most projects. Never assume they don't exist.
+- CRITICAL: Priority and Type are native GitHub ISSUE fields. Set them directly on the issue via issue_write. NEVER use projects_write for them. NEVER use labels for them.
+
+Mandatory workflow when creating issues:
+1. Create the issue with issue_write — set "type" here (e.g. type: "Feature", type: "Bug")
+2. Set priority using the set_issue_priority tool — parameters: owner, repo, issue_number, priority ("urgent"/"high"/"medium"/"low")
+3. Add the issue to the project with projects_write method "add_project_item"
+That's it. No project field updates needed for Priority or Type.
+
+To update priority on an existing issue: use set_issue_priority directly.
+GitHub's REST API does NOT support updating single_select project fields via projects_write (returns 400 "unsupported"). Do not attempt it.
+
+When setting Status on a project item:
+  - Use projects_write method "update_project_item" ONLY for Status (not Priority, not Type)
+  - Get the Status field ID and option IDs first via projects_list method "list_project_fields"
+  - Status option IDs look like hex strings: "f75ad846", "47fc9ee4" — NOT integers
+  - Set Status to "Todo" by default unless told otherwise
+  - Do not set Size, Estimate, or Iteration unless explicitly asked.
+
+Reading issues:
+- NEVER call list_issues. It is forbidden. Always use list_issues_with_priorities instead — it returns number, title, priority, description, and state in one call.
+
+Reading project board status (Todo / In Progress / Done):
+- GitHub issue states (OPEN/CLOSED) are NOT the same as project board status.
+- When the user asks what is "in progress", "todo", or "done", ALWAYS use the list_board_status tool. Never use projects_list for this — it causes context overflow.
+- list_board_status requires owner (org name) and project_number (integer). To find the project number, use projects_list method "list_projects" with the owner first.
+- Never tell the user that "in progress" doesn't exist just because issues are OPEN — always check the project board with list_board_status first.
+
+Rules:
+- Never delete repositories.
+- Never change repository settings.
+- Never create more than 5 issues at once unless clearly asked.
+- Before creating issues, summarize what you are about to create.
+- You are running in a terminal. Use plain text only. No markdown, no bold, no tables, no emojis, no bullet symbols.
+- Always try tools first. Only ask the user for input if the tools truly cannot answer.
+- Before saying you cannot do something, scan all available tools and try any that could be relevant. Never give up after one failed attempt.
+- When you genuinely cannot do something, say so in one short sentence. Do not give the user a wall of manual instructions — they know how to use GitHub's website.

github_mcp_agent/tools.py

@@ -0,0 +1,214 @@
+import json
+import os
+import re
+import subprocess
+import urllib.error
+import urllib.request
+
+from strands import tool
+
+LOCAL_REPO_PATH = os.getcwd()
+
+
+def _gql(query, variables={}):
+    token = os.environ["GITHUB_TOKEN"]
+    data = json.dumps({"query": query, "variables": variables}).encode()
+    req = urllib.request.Request("https://api.github.com/graphql", data=data, method="POST")
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("Content-Type", "application/json")
+    with urllib.request.urlopen(req) as r:
+        return json.loads(r.read())
+
+
+@tool
+def set_issue_priority(owner: str, repo: str, issue_number: int, priority: str) -> str:
+    """Set the Priority field on a GitHub issue. priority: urgent, high, medium, or low."""
+    p = priority.lower()
+    if p not in ("urgent", "high", "medium", "low"):
+        return "Error: priority must be urgent, high, medium, or low"
+    try:
+        lookup = _gql("""
+            query($owner: String!, $repo: String!, $num: Int!) {
+              repository(owner: $owner, name: $repo) { issue(number: $num) { id } }
+              organization(login: $owner) {
+                issueFields(first: 10) {
+                  nodes { ... on IssueFieldSingleSelect { id name options { id name } } }
+                }
+              }
+            }""", {"owner": owner, "repo": repo, "num": issue_number})
+        if "errors" in lookup:
+            return f"Error: {lookup['errors'][0]['message']}"
+        issue_id = lookup["data"]["repository"]["issue"]["id"]
+        pf = next((f for f in lookup["data"]["organization"]["issueFields"]["nodes"] if f.get("name") == "Priority"), None)
+        if not pf:
+            return "Priority field not found in org"
+        opt = next((o for o in pf["options"] if o["name"].lower() == p), None)
+        if not opt:
+            return f"Option '{p}' not found"
+        result = _gql("""
+            mutation($i: ID!, $f: ID!, $o: ID!) {
+              updateIssueFieldValue(input: {
+                issueId: $i
+                issueField: { fieldId: $f, singleSelectOptionId: $o }
+              }) { clientMutationId }
+            }""", {"i": issue_id, "f": pf["id"], "o": opt["id"]})
+        if "errors" in result:
+            return f"Error: {result['errors'][0]['message']}"
+        return f"Priority set to '{p}' on {owner}/{repo}#{issue_number}"
+    except urllib.error.HTTPError as e:
+        return f"HTTP {e.code}: {e.read().decode()}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+@tool
+def list_issues_with_priorities(owner: str, repo: str, state: str = "OPEN") -> str:
+    """List issues with their priority AND description in one call. Use this instead of list_issues whenever priorities matter. state: OPEN, CLOSED, or ALL."""
+    try:
+        result = _gql("""
+            query($owner: String!, $repo: String!, $state: [IssueState!]) {
+              repository(owner: $owner, name: $repo) {
+                issues(first: 100, states: $state, orderBy: {field: CREATED_AT, direction: DESC}) {
+                  nodes {
+                    number title body state
+                    issueFieldValues(first: 5) {
+                      nodes {
+                        ... on IssueFieldSingleSelectValue {
+                          name
+                          field { ... on IssueFieldSingleSelect { name } }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }""", {"owner": owner, "repo": repo, "state": [state] if state != "ALL" else ["OPEN", "CLOSED"]})
+        if "errors" in result:
+            return f"Error: {result['errors'][0]['message']}"
+        lines = []
+        for issue in result["data"]["repository"]["issues"]["nodes"]:
+            priority = "not set"
+            for fv in issue.get("issueFieldValues", {}).get("nodes", []):
+                if fv.get("field", {}).get("name") == "Priority":
+                    priority = fv.get("name", "not set").lower()
+                    break
+            body = (issue.get("body") or "").strip().replace("\n", " ")[:150]
+            lines.append(f"#{issue['number']} [{issue['state']}] {issue['title']} | Priority: {priority} | {body}")
+        return "\n".join(lines) or "No issues found"
+    except urllib.error.HTTPError as e:
+        return f"HTTP {e.code}: {e.read().decode()}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+@tool
+def list_board_status(owner: str, project_number: int) -> str:
+    """List all project board items grouped by their Status (Todo / In Progress / Done). Use this when the user asks about board status, what is in progress, or what is done. Never use projects_list for this — it overflows."""
+    try:
+        result = _gql("""
+            query($owner: String!, $num: Int!) {
+              organization(login: $owner) {
+                projectV2(number: $num) {
+                  items(first: 100) {
+                    nodes {
+                      content {
+                        ... on Issue { number title state }
+                      }
+                      fieldValues(first: 10) {
+                        nodes {
+                          ... on ProjectV2ItemFieldSingleSelectValue {
+                            name
+                            field { ... on ProjectV2SingleSelectField { name } }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }""", {"owner": owner, "num": project_number})
+        if "errors" in result:
+            return f"Error: {result['errors'][0]['message']}"
+        buckets: dict = {}
+        for item in result["data"]["organization"]["projectV2"]["items"]["nodes"]:
+            content = item.get("content") or {}
+            if not content.get("number"):
+                continue
+            number = content["number"]
+            title = content.get("title", "")
+            status = "No Status"
+            for fv in item.get("fieldValues", {}).get("nodes", []):
+                if fv.get("field", {}).get("name") == "Status":
+                    status = fv.get("name", "No Status")
+                    break
+            buckets.setdefault(status, []).append(f"  #{number} {title}")
+        lines = []
+        for status, items in buckets.items():
+            lines.append(f"{status} ({len(items)}):")
+            lines.extend(items)
+            lines.append("")
+        return "\n".join(lines) or "No items found"
+    except urllib.error.HTTPError as e:
+        return f"HTTP {e.code}: {e.read().decode()}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+@tool
+def read_local_file(path: str) -> str:
+    """Read a file from the local repository. Path is relative to the repo root."""
+    full_path = os.path.normpath(os.path.join(LOCAL_REPO_PATH, path))
+    if not full_path.startswith(LOCAL_REPO_PATH):
+        return "Error: path outside repo root"
+    try:
+        with open(full_path) as f:
+            return f.read()
+    except FileNotFoundError:
+        return f"File not found: {path}"
+    except Exception as e:
+        return f"Error reading file: {e}"
+
+
+@tool
+def list_local_files(path: str = ".") -> str:
+    """List files and directories in the local repository. Path is relative to the repo root."""
+    full_path = os.path.normpath(os.path.join(LOCAL_REPO_PATH, path))
+    if not full_path.startswith(LOCAL_REPO_PATH):
+        return "Error: path outside repo root"
+    try:
+        entries = []
+        for entry in sorted(os.scandir(full_path), key=lambda e: (not e.is_dir(), e.name)):
+            prefix = "/" if entry.is_dir() else ""
+            entries.append(f"{entry.name}{prefix}")
+        return "\n".join(entries)
+    except FileNotFoundError:
+        return f"Directory not found: {path}"
+    except Exception as e:
+        return f"Error listing files: {e}"
+
+
+@tool
+def detect_current_repo() -> str:
+    """Detect the GitHub repository the user is currently working in, based on the local git remote origin URL."""
+    try:
+        url = subprocess.check_output(
+            ["git", "remote", "get-url", "origin"],
+            stderr=subprocess.DEVNULL,
+            cwd=os.getcwd(),
+        ).decode().strip()
+        match = re.search(r"github\.com[:/](.+?)(?:\.git)?$", url)
+        if match:
+            return match.group(1)
+    except Exception:
+        pass
+    return "No GitHub remote detected"
+
+
+local_tools = [
+    set_issue_priority,
+    list_issues_with_priorities,
+    list_board_status,
+    detect_current_repo,
+    read_local_file,
+    list_local_files,
+]

github_mcp_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: github-mcp-agent
+Version: 0.1.0
+Summary: A GitHub AI agent powered by AWS Bedrock and MCP
+Requires-Python: >=3.10
+Requires-Dist: anthropic
+Requires-Dist: boto3
+Requires-Dist: click
+Requires-Dist: litellm
+Requires-Dist: mcp
+Requires-Dist: python-dotenv
+Requires-Dist: questionary
+Requires-Dist: rich
+Requires-Dist: strands-agents

github_mcp_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+github_mcp_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+github_mcp_agent/agent.py,sha256=vbMm-pGsYOD-z0TeUIfczdbXPrdi62jK-GK1ZwesFog,3520
+github_mcp_agent/cli.py,sha256=0phwP9dRWzKzOzc6R-uZZQIWpwFtrJUammhe4Jyc3_k,6342
+github_mcp_agent/setup_wizard.py,sha256=RD0az_GsXI8zzB2_GQeNsO9JNoUGYdMc9isguTf8fys,4640
+github_mcp_agent/system_prompt.txt,sha256=K67KFba4IzsYd9priF-7ORFTRvWB0wqonlN4p3H01Do,4532
+github_mcp_agent/tools.py,sha256=xg-EglraCAHamEkYeNcavdNc2UyGMFamNr1F6BTrGtY,8602
+github_mcp_agent/providers/__init__.py,sha256=xdDXQVtKXE5A_cKjh5w9wD8tJBiZ7sJnNfYYng7MbTw,907
+github_mcp_agent/providers/anthropic.py,sha256=DvJpbuMghY871zGbSuQ5NHiRQl0HZj_TedZU7XYMYVU,1022
+github_mcp_agent/providers/bedrock.py,sha256=-HJFM0e-TgnPxEErkeaV7B6CBiutTKDklEIGNdMYRxE,4619
+github_mcp_agent/providers/copilot.py,sha256=kmFsE7V6vxRn0vIQfRCw5j48SVi2kUnjblEdXWXqzUU,1208
+github_mcp_agent/providers/gemini.py,sha256=6h2A1374mKBrjb9flJh0gmjhxjcmbEOv1_Iov1OCutM,980
+github_mcp_agent/providers/ollama.py,sha256=2Qtx6crnH7FwnpN_nlej9kl5_tO4UC26vGexnpBHVU4,2633
+github_mcp_agent/providers/openai.py,sha256=JpjlbccDuq7btdudA5PBbcjYVv5tyNCAGbVHQ0U2Kr0,937
+github_mcp_agent-0.1.0.dist-info/METADATA,sha256=l6XFCYlQbs4YDtlGztiB-uMuUwOw2c_pNCVSNgEibUc,357
+github_mcp_agent-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+github_mcp_agent-0.1.0.dist-info/entry_points.txt,sha256=ubnAt2X37Z0pEbZWMoS2rLMHIsI-1vtqS433IY6aZAk,59
+github_mcp_agent-0.1.0.dist-info/RECORD,,

github_mcp_agent-0.1.0.dist-info/WHEEL

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

github_mcp_agent-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+github-agent = github_mcp_agent.cli:main