github-mcp-agent 0.1.0__tar.gz

github_mcp_agent-0.1.0/.claude/settings.json

@@ -0,0 +1,5 @@
+{
+  "permissions": {
+    "deny": ["Read(.env)", "Read(.env.*)"]
+  }
+}

github_mcp_agent-0.1.0/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Skill(update-config)",
+      "Skill(update-config:*)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "WebFetch(domain:docs.github.com)",
+      "WebFetch(domain:api.github.com)",
+      "WebSearch"
+    ]
+  }
+}

github_mcp_agent-0.1.0/.env.example

@@ -0,0 +1,3 @@
+GITHUB_TOKEN=your_github_token_here
+AWS_REGION=eu-west-3
+MODEL_ID=anthropic.claude-3-5-sonnet-20240620-v1:0

github_mcp_agent-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+.env
+.venv/
+__pycache__/
+*.pyc

github_mcp_agent-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,108 @@
+# GitHub MCP Agent
+
+Talk to your GitHub repos, issues, and project boards in plain English from your terminal.
+
+```
+You > list open issues in my raytracer repo
+You > set priority of issue #42 to urgent
+You > what's in progress on the project board?
+You > which issues are assigned to maryam?
+```
+
+---
+
+## Install
+
+```bash
+git clone https://github.com/OmarCodes022/GitHub-MCP-Agent
+cd GitHub-MCP-Agent
+uv tool install .   # or: pip install .
+```
+
+---
+
+## Setup
+
+```bash
+github-agent setup
+```
+
+Interactive wizard:
+
+1. GitHub token (validated immediately)
+2. AI provider — choose one:
+   - **AWS Bedrock** — existing profile, access keys, or SSO
+   - **Anthropic API** — API key from console.anthropic.com
+   - **OpenAI** — API key from platform.openai.com
+   - **Google Gemini** — API key from aistudio.google.com
+   - **GitHub Copilot** — uses your GitHub token, requires a Copilot subscription
+   - **Local (Ollama)** — picks from your installed models, no API key needed
+3. Model selection (scrollable menu)
+4. Pulls the GitHub MCP Docker image
+
+Config saved to `~/.config/github-mcp-agent/.env`.
+
+---
+
+## Usage
+
+```bash
+github-agent            # start the agent
+github-agent setup      # full setup wizard
+github-agent provider   # switch AI provider and model
+github-agent model      # switch model within current provider
+github-agent token      # update GitHub token
+github-agent config     # edit config file in $EDITOR
+github-agent prompt     # customize the system prompt in $EDITOR
+github-agent -v         # start with verbose tool output
+```
+
+---
+
+## Requirements
+
+| Requirement | Notes |
+|---|---|
+| Python 3.10+ | |
+| Docker | Must be running — used for the GitHub MCP server |
+| GitHub token | Scopes: `repo`, `read:org`, `project` — [github.com/settings/tokens](https://github.com/settings/tokens) |
+| Provider credentials | See setup wizard |
+
+**For AWS Bedrock:** enable Claude model access in the [Bedrock console](https://console.aws.amazon.com/bedrock) under Model access.
+
+**For Ollama:** install from [ollama.com](https://ollama.com), run `ollama serve`. Models with good tool-calling support: `qwen2.5`, `llama3.1`, `mistral`.
+
+**For GitHub Copilot:** requires an active Copilot subscription (student pack, individual, or business).
+
+---
+
+## How it works
+
+```
+You (terminal)
+    │
+    ▼
+github-agent (CLI)
+    │
+    ├── AI model (Bedrock / Anthropic / OpenAI / Gemini / Copilot / Ollama)
+    │
+    └── GitHub MCP Server (Docker)
+            │
+            └── GitHub API
+```
+
+Uses the [Strands Agents SDK](https://github.com/strands-agents/sdk-python) with the [GitHub MCP server](https://github.com/github/github-mcp-server).
+
+---
+
+## Troubleshooting
+
+**`GITHUB_TOKEN` not set** — run `github-agent setup`
+
+**Docker not running** — start Docker Desktop or `sudo systemctl start docker`
+
+**Bedrock access denied** — check IAM permissions and model access in your region
+
+**Ollama model not found** — run `ollama list` to confirm the model name, re-run `github-agent model`
+
+**`No module named github_mcp_agent`** — reinstall with `uv tool install .` from the project directory

github_mcp_agent-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.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-0.1.0/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-0.1.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],
+    }