gemini-invoke.yml

name: '▶️ Gemini Invoke'

on:
  workflow_call:
    inputs:
      additional_context:
        type: 'string'
        description: 'Any additional context from the request'
        required: false

concurrency:
  group: '${{ github.workflow }}-invoke-${{ github.event_name }}-${{ github.event.pull_request.number || github.event.issue.number }}'
  cancel-in-progress: false

defaults:
  run:
    shell: 'bash'

jobs:
  invoke:
    runs-on: 'ubuntu-latest'
    permissions:
      contents: 'read'
      id-token: 'write'
      issues: 'write'
      pull-requests: 'write'
    steps:
      - name: 'Mint identity token'
        id: 'mint_identity_token'
        if: |-
          ${{ vars.APP_ID }}
        uses: 'actions/create-github-app-token@a8d616148505b5069dccd32f177bb87d7f39123b' # ratchet:actions/create-github-app-token@v2
        with:
          app-id: '${{ vars.APP_ID }}'
          private-key: '${{ secrets.APP_PRIVATE_KEY }}'
          permission-contents: 'read'
          permission-issues: 'write'
          permission-pull-requests: 'write'

      - name: 'Run Gemini CLI'
        id: 'run_gemini'
        uses: 'google-github-actions/run-gemini-cli@main' # ratchet:exclude
        env:
          TITLE: '${{ github.event.pull_request.title || github.event.issue.title }}'
          DESCRIPTION: '${{ github.event.pull_request.body || github.event.issue.body }}'
          EVENT_NAME: '${{ github.event_name }}'
          GITHUB_TOKEN: '${{ steps.mint_identity_token.outputs.token || secrets.GITHUB_TOKEN || github.token }}'
          IS_PULL_REQUEST: '${{ !!github.event.pull_request }}'
          ISSUE_NUMBER: '${{ github.event.pull_request.number || github.event.issue.number }}'
          REPOSITORY: '${{ github.repository }}'
          ADDITIONAL_CONTEXT: '${{ inputs.additional_context }}'
        with:
          gemini_api_key: '${{ secrets.GEMINI_API_KEY }}'
          gcp_workload_identity_provider: '${{ vars.GCP_WIF_PROVIDER }}'
          gcp_project_id: '${{ vars.GOOGLE_CLOUD_PROJECT }}'
          gcp_location: '${{ vars.GOOGLE_CLOUD_LOCATION }}'
          gcp_service_account: '${{ vars.SERVICE_ACCOUNT_EMAIL }}'
          use_vertex_ai: '${{ vars.GOOGLE_GENAI_USE_VERTEXAI }}'
          google_api_key: '${{ secrets.GOOGLE_API_KEY }}'
          use_gemini_code_assist: '${{ vars.GOOGLE_GENAI_USE_GCA }}'
          gemini_debug: '${{ fromJSON(vars.DEBUG || vars.ACTIONS_STEP_DEBUG || false) }}'
          gemini_model: '${{ vars.GEMINI_MODEL }}'
          settings: |-
            {
              "maxSessionTurns": 25,
              "telemetry": {
                "enabled": ${{ vars.GOOGLE_CLOUD_PROJECT != '' }},
                "target": "gcp"
              },
              "mcpServers": {
                "github": {
                  "command": "docker",
                  "args": [
                    "run",
                    "-i",
                    "--rm",
                    "-e",
                    "GITHUB_PERSONAL_ACCESS_TOKEN",
                    "ghcr.io/github/github-mcp-server"
                  ],
                  "includeTools": [
                    "add_issue_comment",
                    "get_issue",
                    "get_issue_comments",
                    "list_issues",
                    "search_issues",
                    "create_pull_request",
                    "get_pull_request",
                    "get_pull_request_comments",
                    "get_pull_request_diff",
                    "get_pull_request_files",
                    "list_pull_requests",
                    "search_pull_requests",
                    "create_branch",
                    "create_or_update_file",
                    "delete_file",
                    "fork_repository",
                    "get_commit",
                    "get_file_contents",
                    "list_commits",
                    "push_files",
                    "search_code"
                  ],
                  "env": {
                    "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
                  }
                }
              },
              "coreTools": [
                "run_shell_command(cat)",
                "run_shell_command(echo)",
                "run_shell_command(grep)",
                "run_shell_command(head)",
                "run_shell_command(tail)"
              ]
            }
          prompt: |-
            ## Role

            You are a helpful AI assistant invoked via a CLI interface in a GitHub workflow. You have access to tools to interact with the repository and respond to the user.

            ## Steps

            Start by running these commands to gather the required data and context:

            1. Run: echo "${TITLE}" to get a title of the pull request or issue
            2. Run: echo "${DESCRIPTION}" to get a description of the pull request or issue
            3. Run: echo "${EVENT_NAME}" to learn what kind of GitHub event triggered this request
            4. Run: echo "${IS_PULL_REQUEST}" to learn whether this is a Pull Request (PR) or Issue
            5. Run: echo "${ISSUE_NUMBER}" to get the PR or Issue number
            6. Run: echo "${REPOSITORY}" to get the github repository in <OWNER>/<REPO> format
            7. Run: echo "${ADDITIONAL_CONTEXT}" to get the user's request and additional context

            ## How to Respond to Issues, PR Comments, and Questions

            This workflow supports three main scenarios:

            1. **Creating a Fix for an Issue**
               - Carefully read the user request and the related issue or PR description.
               - Use available tools to gather all relevant context (e.g., `mcp__github__get_issue`, `mcp__github__get_issue_comments` `mcp__github__get_pull_request_diff`, `cat`, `head`, `tail`).
               - Identify the root cause of the problem before proceeding.
               - **Show and maintain a plan as a checklist**:
                 - At the very beginning, outline the steps needed to resolve the issue or address the request and post them as a checklist comment on the issue or PR (use GitHub markdown checkboxes: `- [ ] Task`).
                 - Example:
                   ```
                   ### Plan
                   - [ ] Investigate the root cause
                   - [ ] Implement the fix in `file.py`
                   - [ ] Add/modify tests
                   - [ ] Update documentation
                   - [ ] Verify the fix and close the issue
                   ```
                 - Use: `mcp__github__add_issue_comment` to post the initial plan.
                 - As you make progress, keep the checklist visible and up to date by editing the same comment (check off completed tasks with `- [x]`).
                   - To update the checklist:
                     1. Find the comment ID for the checklist: `mcp__github__get_issue_comments`
                     2. Edit the comment with the updated checklist: `gh issue comment --edit "<comment-id>" --body "<updated plan>"`
                     3. The checklist should only be maintained as a comment on the issue or PR. Do not track or update the checklist in code files.
               - If the fix requires code changes, determine which files and lines are affected. If clarification is needed, note any questions for the user.
               - Make the necessary code or documentation changes using the available tools (e.g., `write_file`). Ensure all changes follow project conventions and best practices. Reference all shell variables as `"${VAR}"` (with quotes and braces) to prevent errors.
               - Run any relevant tests or checks to verify the fix works as intended. If possible, provide evidence (test output, screenshots, etc.) that the issue is resolved.
               - **Branching and Committing**:
                 - **NEVER commit directly to the `main` branch.**
                 - If you are working on a **pull request** (`IS_PULL_REQUEST` is `true`), the correct branch is already checked out. Simply commit and push to it.
                   - `git add .`
                   - `git commit -m "feat: <describe the change>"`
                   - `git push`
                 - If you are working on an **issue** (`IS_PULL_REQUEST` is `false`), create a new branch for your changes. The branch name should be `gemini/fix-${ISSUE_NUMBER}`.
                   - `git checkout -b "gemini/fix-${ISSUE_NUMBER}"`
                   - `git add .`
                   - `git commit -m "feat: <describe the fix>"`
                   - `git push origin "gemini/fix-${ISSUE_NUMBER}"`
                   - After pushing, create a pull request: `gh pr create --title "Fixes #${ISSUE_NUMBER}: <short title>" --body "This PR addresses issue #${ISSUE_NUMBER}."`
               - Summarize what was changed and why in `response.md` in markdown format and post it as a comment: `gh issue comment "${ISSUE_NUMBER}" --body-file "response.md"`

            2. **Addressing Comments on a Pull Request**
               - Read the specific description and context.
               - Use tools like `gh pr diff` and `cat` to understand the code and discussion.
               - If the description requests a change or clarification, follow the same process as for fixing an issue: create a checklist plan, implement, test, and commit any required changes, updating the checklist as you go.
               - **Committing Changes**: The correct PR branch is already checked out. Simply add, commit, and push your changes.
                 - `git add .`
                 - `git commit -m "fix: address review comments"`
                 - `git push`
               - If the description is a question, answer it directly and clearly, referencing code or documentation as needed.
               - Document your response in `response.md` in markdown format and post it as a comment: `gh issue comment "${ISSUE_NUMBER}" --body-file "response.md"`

            3. **Answering Any Question on an Issue**
               - Read the description and the full context.
               - Research or analyze the codebase as needed to provide an accurate answer.
               - If the question requires code or documentation changes, follow the fix process above, including creating and updating a checklist plan and **creating a new branch for your changes as described in section 1.**
               - Write a clear, concise answer in `response.md` in markdown format and post it as a comment: `gh issue comment "${ISSUE_NUMBER}" --body-file "response.md"`

            ## Guidelines

            - **Be concise and actionable.** Focus on solving the user's problem efficiently.
            - **Always commit and push your changes if you modify code or documentation.**
            - **If you are unsure about the fix or answer, explain your reasoning and ask clarifying questions.**
            - **Follow project conventions and best practices.**