brainiac-github 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4606ec0c07107e122e51570364e05d20db3d0717e7a6679cdff85471f38e0b5
-  data.tar.gz: 73ad18ee4563e0e55d56a1cab2f8f8714484d3fee3bbc1c3763ec1e2886221eb
+  metadata.gz: 7ad5b0842a1e9731e535de2a742f69efa1a243e956d34d3b2a3ec8f04813ec96
+  data.tar.gz: 4d01970f8f0ca48975fc66fb8197d0b94c16b0797eed937123af4c0639163168
 SHA512:
-  metadata.gz: 9c7240c8f7a3a1b57e72bc6245a50d7089c82736e6e0259c2944ca623fbb6839f564064b75788c3b8fc60489393b0fdc65ff932410da878b2bb19bc16327c801
-  data.tar.gz: 05405f8388fe9c817d4c2b59edde95f5ac6819112fa1f30f24d486a35a37c2dd417aad3f0c17f760e237f1d54681508e436cd1820f6b56eea5a1fc6ec77d1e96
+  metadata.gz: 4d637b12f74f47258614b8114efa550baac3ef11073c3dd4320edd637335e761aa5ec50601d4042c119d4ac988cc6ebbe26f34a0905071a2b205725b9749d7a7
+  data.tar.gz: 279d75d005d2889eb5373b0161764cd82459ada1aab2e022c1449793a56bd0910592008f71a860909595e6da54bfe66de6349f8323a1510171feacb81d5815aa

data/README.md

@@ -24,6 +24,11 @@ Config lives at `~/.brainiac/github.json`:
 ```json
 {
   "webhook_secret": "your-github-webhook-secret",
+  "app": {
+    "id": "123456",
+    "private_key_path": "~/.brainiac/github-app-private-key.pem",
+    "installation_id": "78901234"
+  },
   "repos": {}
 }
 ```
@@ -34,6 +39,49 @@ Generate a webhook secret:
 ruby -rsecurerandom -e 'puts SecureRandom.hex(20)'
 ```
 
+### GitHub App Setup (Recommended)
+
+Using a GitHub App makes PR comments and reactions appear as the app's bot user
+(e.g. "brainiac-bot") instead of your personal account. This gives each agent a
+distinct identity in PR conversations.
+
+1. Go to **Settings → Developer settings → GitHub Apps → New GitHub App**
+2. Set the following:
+   - **Name**: e.g. `brainiac-bot`
+   - **Homepage URL**: your Brainiac instance URL
+   - **Webhook URL**: leave blank (webhook is handled by the plugin directly)
+   - **Permissions**:
+     - Pull requests: Read & Write
+     - Issues: Read & Write
+     - Contents: Read (for fetching PR diffs)
+   - **Events**: uncheck everything (events come via the repo webhook, not the app)
+3. Create the app and note the **App ID** from the app's settings page
+4. Generate a private key (`.pem` file) and save it to `~/.brainiac/github-app-private-key.pem`
+5. Install the app on your org/repos and note the **Installation ID** from the URL:
+   `https://github.com/settings/installations/INSTALLATION_ID`
+6. Add the credentials to your `github.json`:
+   ```json
+   {
+     "app": {
+       "id": "123456",
+       "private_key_path": "~/.brainiac/github-app-private-key.pem",
+       "installation_id": "78901234"
+     }
+   }
+   ```
+
+If app credentials are not configured, the plugin falls back to using the `gh` CLI
+(which authenticates as your personal GitHub account).
+
+### Environment Variables
+
+As an alternative to config file values, you can set:
+
+- `GITHUB_WEBHOOK_SECRET` — webhook signature secret
+- `GITHUB_APP_ID` — GitHub App ID
+- `GITHUB_APP_PRIVATE_KEY_PATH` — path to the `.pem` private key file
+- `GITHUB_APP_INSTALLATION_ID` — installation ID
+
 ### GitHub Webhook Setup
 
 1. Go to your repo → Settings → Webhooks → Add webhook

data/lib/brainiac/plugins/github/app_client.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "openssl"
+require "jwt"
+require "time"
+
+module Brainiac
+  module Plugins
+    module Github
+      # HTTP client that authenticates as a GitHub App (installation).
+      #
+      # When app credentials are configured (app_id + private_key_path + installation_id),
+      # API calls are made as the App's bot user — so PR comments, reactions, etc.
+      # appear with the App's identity rather than a personal user.
+      #
+      # Falls back to `gh` CLI when app credentials are not configured.
+      module AppClient
+        GITHUB_API = "https://api.github.com"
+        TOKEN_EXPIRY_BUFFER = 60 # refresh token 60s before expiry
+
+        @token = nil
+        @token_expires_at = nil
+        @mutex = Mutex.new
+
+        class << self
+          # Returns true if GitHub App credentials are fully configured.
+          def configured?
+            !!(Config.app_id && Config.private_key_path && Config.installation_id)
+          end
+
+          # POST a comment on an issue or PR.
+          #
+          # @param repo [String] "owner/repo"
+          # @param pr_number [Integer]
+          # @param body [String] comment markdown
+          # @return [Hash] parsed response
+          def create_comment(repo, pr_number, body)
+            post("/repos/#{repo}/issues/#{pr_number}/comments", { body: body })
+          end
+
+          # POST a reaction on an issue comment.
+          #
+          # @param repo [String] "owner/repo"
+          # @param comment_id [Integer]
+          # @param reaction [String] e.g. "eyes", "+1", "rocket"
+          # @return [Hash] parsed response
+          def create_comment_reaction(repo, comment_id, reaction)
+            post("/repos/#{repo}/issues/comments/#{comment_id}/reactions", { content: reaction })
+          end
+
+          # POST a reaction on a PR review.
+          #
+          # @param repo [String] "owner/repo"
+          # @param review_id [Integer]
+          # @param reaction [String]
+          # @return [Hash] parsed response
+          def create_review_reaction(repo, review_id, reaction)
+            post("/repos/#{repo}/pulls/reviews/#{review_id}/reactions", { content: reaction })
+          end
+
+          # GET request to GitHub API.
+          #
+          # @param path [String] API path (e.g. "/repos/owner/repo/pulls/1")
+          # @return [Hash] parsed response
+          def get(path)
+            request(:get, path)
+          end
+
+          # POST request to GitHub API.
+          #
+          # @param path [String] API path
+          # @param body [Hash] request body
+          # @return [Hash] parsed response
+          def post(path, body)
+            request(:post, path, body)
+          end
+
+          # Reset cached token (useful for testing or when credentials change).
+          def reset!
+            @mutex.synchronize do
+              @token = nil
+              @token_expires_at = nil
+            end
+          end
+
+          private
+
+          def request(method, path, body = nil)
+            token = installation_token
+            uri = URI("#{GITHUB_API}#{path}")
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.open_timeout = 10
+            http.read_timeout = 30
+
+            req = case method
+                  when :get
+                    Net::HTTP::Get.new(uri.request_uri)
+                  when :post
+                    Net::HTTP::Post.new(uri.request_uri)
+                  end
+
+            req["Authorization"] = "Bearer #{token}"
+            req["Accept"] = "application/vnd.github+json"
+            req["X-GitHub-Api-Version"] = "2022-11-28"
+            req["User-Agent"] = "Brainiac-GitHub-App"
+            req.body = JSON.generate(body) if body
+            req.content_type = "application/json" if body
+
+            response = http.request(req)
+
+            raise "GitHub API error #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+            JSON.parse(response.body)
+          end
+
+          # Generate a short-lived JWT signed with the App's private key.
+          # Used to request an installation access token.
+          def generate_jwt
+            private_key = OpenSSL::PKey::RSA.new(File.read(Config.private_key_path))
+            now = Time.now.to_i
+
+            payload = {
+              iat: now - 60, # issued at (60s clock drift allowance)
+              exp: now + (10 * 60), # expires in 10 minutes (max allowed)
+              iss: Config.app_id
+            }
+
+            JWT.encode(payload, private_key, "RS256")
+          end
+
+          # Fetch or return a cached installation access token.
+          # Tokens are valid for 1 hour; we refresh 60s early.
+          def installation_token
+            @mutex.synchronize do
+              return @token if @token && @token_expires_at && Time.now.to_i < @token_expires_at
+
+              jwt = generate_jwt
+              uri = URI("#{GITHUB_API}/app/installations/#{Config.installation_id}/access_tokens")
+
+              http = Net::HTTP.new(uri.host, uri.port)
+              http.use_ssl = true
+              http.open_timeout = 10
+              http.read_timeout = 30
+
+              req = Net::HTTP::Post.new(uri.request_uri)
+              req["Authorization"] = "Bearer #{jwt}"
+              req["Accept"] = "application/vnd.github+json"
+              req["X-GitHub-Api-Version"] = "2022-11-28"
+              req["User-Agent"] = "Brainiac-GitHub-App"
+
+              response = http.request(req)
+
+              raise "Failed to get installation token: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+              data = JSON.parse(response.body)
+              @token = data["token"]
+              # Parse expiry, subtract buffer
+              expires_at = Time.parse(data["expires_at"]).to_i
+              @token_expires_at = expires_at - TOKEN_EXPIRY_BUFFER
+              @token
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brainiac/plugins/github/cli.rb

@@ -51,10 +51,27 @@ module Brainiac
 
             config = JSON.parse(File.read(config_file))
             secret = config["webhook_secret"]
+            app_config = config["app"] || {}
+
             puts "GitHub Configuration:"
             puts "  Config file: #{config_file}"
             puts "  Webhook secret: #{secret && !secret.empty? ? "#{secret[0..5]}..." : "(not set)"}"
             puts "  Repos: #{config.fetch("repos", {}).keys.join(", ").then { |s| s.empty? ? "(none)" : s }}"
+            puts ""
+            puts "  App Authentication:"
+            if app_config["id"] && !app_config["id"].to_s.empty?
+              puts "    App ID: #{app_config["id"]}"
+              puts "    Private key: #{app_config["private_key_path"] || "(not set)"}"
+              puts "    Installation ID: #{app_config["installation_id"] || "(not set)"}"
+              key_path = app_config["private_key_path"]
+              if key_path && File.exist?(File.expand_path(key_path))
+                puts "    Status: ✅ configured"
+              else
+                puts "    Status: ⚠️  private key file not found"
+              end
+            else
+              puts "    Status: not configured (using gh CLI fallback)"
+            end
           end
 
           def cmd_status

data/lib/brainiac/plugins/github/config.rb

@@ -22,6 +22,7 @@ module Brainiac
 
             @config = load_config
             @last_mtime = File.exist?(CONFIG_FILE) ? File.mtime(CONFIG_FILE) : nil
+            AppClient.reset! if defined?(AppClient)
             LOG.info "[GitHub] Reloaded configuration"
           end
 
@@ -29,6 +30,24 @@ module Brainiac
             @config["webhook_secret"] || ENV.fetch("GITHUB_WEBHOOK_SECRET", nil)
           end
 
+          # GitHub App credentials — all three must be present for App auth to work.
+
+          def app_id
+            @config.dig("app", "id")&.to_s || ENV.fetch("GITHUB_APP_ID", nil)
+          end
+
+          def private_key_path
+            path = @config.dig("app", "private_key_path") || ENV.fetch("GITHUB_APP_PRIVATE_KEY_PATH", nil)
+            return nil unless path
+
+            expanded = File.expand_path(path)
+            File.exist?(expanded) ? expanded : nil
+          end
+
+          def installation_id
+            @config.dig("app", "installation_id")&.to_s || ENV.fetch("GITHUB_APP_INSTALLATION_ID", nil)
+          end
+
           private
 
           def load_config

data/lib/brainiac/plugins/github/handler.rb

@@ -35,7 +35,7 @@ module Brainiac
             end
 
             _internal_id, card_info = result
-            card_number = card_info["number"]
+            card_number = extract_card_number(card_info)
             unless card_number
               LOG.warn "Card has no number — can't comment or move"
               return [200, { status: "ignored", reason: "card has no number" }.to_json]
@@ -63,7 +63,7 @@ module Brainiac
             return [200, { status: "ignored", reason: "no matching card" }.to_json] unless result
 
             _internal_id, card_info = result
-            card_number = card_info["number"]
+            card_number = extract_card_number(card_info)
             worktree = card_info["worktree"]
 
             return [200, { status: "ignored", reason: "no worktree" }.to_json] unless worktree && File.directory?(worktree)
@@ -104,17 +104,16 @@ module Brainiac
 
             if result
               _internal_id, card_info = result
-              card_number = card_info["number"]
+              card_number = extract_card_number(card_info)
               unless card_number
                 LOG.warn "Card has no number — can't dispatch review"
                 return [200, { status: "ignored", reason: "card has no number" }.to_json]
               end
-              card_key = "card-#{card_number}"
             else
               card_info = {}
               card_number = nil
-              card_key = "pr-#{repo_name.tr("/", "-")}-#{pr_number}"
             end
+            card_key = "pr-review-#{repo_name.tr("/", "-")}-#{pr_number}"
 
             return [200, { status: "ignored", reason: "session already active" }.to_json] if session_active?(card_key)
 
@@ -151,15 +150,20 @@ module Brainiac
             project_key, project_config = project_result
             pr_number = issue["number"]
 
-            pr_data = run_cmd("gh", "api", "/repos/#{repo_name}/pulls/#{pr_number}", "--jq", "{branch: .head.ref}",
-                              chdir: project_config["repo_path"])
-            branch = JSON.parse(pr_data)["branch"]
+            if AppClient.configured?
+              pr_response = AppClient.get("/repos/#{repo_name}/pulls/#{pr_number}")
+              branch = pr_response.dig("head", "ref")
+            else
+              pr_data = run_cmd("gh", "api", "/repos/#{repo_name}/pulls/#{pr_number}", "--jq", "{branch: .head.ref}",
+                                chdir: project_config["repo_path"])
+              branch = JSON.parse(pr_data)["branch"]
+            end
 
             result = find_work_item_by_branch(branch)
 
             if result
               _, card_info = result
-              card_number = card_info["number"]
+              card_number = extract_card_number(card_info)
               worktree = card_info["worktree"]
 
               unless worktree && File.directory?(worktree)
@@ -167,12 +171,11 @@ module Brainiac
                 return [200, { status: "ignored", reason: "no active worktree" }.to_json]
               end
 
-              card_key = "card-#{card_number}"
             else
               card_number = nil
               worktree = project_config["repo_path"]
-              card_key = "pr-#{repo_name.tr("/", "-")}-#{pr_number}"
             end
+            card_key = "pr-comment-#{repo_name.tr("/", "-")}-#{pr_number}"
 
             if session_active?(card_key)
               LOG.info "Skipping PR comment on #{card_key} — agent session already active"
@@ -245,6 +248,28 @@ module Brainiac
             nil
           end
 
+          # Extract the card number from a work item info hash, supporting both
+          # the old flat format ("number") and new source-based format ("sources.fizzy.card_number").
+          def extract_card_number(card_info)
+            card_info["number"] || card_info.dig("sources", "fizzy", "card_number")
+          end
+
+          # Extract PRs array from a work item, supporting both old flat format and new source-based format.
+          def extract_prs(card_info)
+            card_info.dig("sources", "github", "prs") || card_info["prs"] || []
+          end
+
+          # Store PRs in the correct location based on the work item format.
+          def store_prs(card_info, prs)
+            if card_info.key?("sources")
+              card_info["sources"] ||= {}
+              card_info["sources"]["github"] ||= {}
+              card_info["sources"]["github"]["prs"] = prs
+            else
+              card_info["prs"] = prs
+            end
+          end
+
           def process_merged_pr(card_info, card_number, branch, pull_request, pr_url, pr_title, project_key, project_config, repo_path)
             mark_work_item_merged(card_number)
             cleanup_work_item_worktrees(card_number, repo_path: repo_path,
@@ -270,23 +295,27 @@ module Brainiac
             end
 
             internal_id, card_info = result
-            prs = card_info["prs"] || []
+            prs = extract_prs(card_info)
             return if prs.any? { |p| p["number"] == pr_number }
 
             prs << { "number" => pr_number, "url" => pr_url }
-            card_info["prs"] = prs
+            store_prs(card_info, prs)
 
             map = load_work_item_map
             map[internal_id] = card_info
             save_work_item_map(map)
-            LOG.info "[PR Track] Tracked PR ##{pr_number} on card ##{card_info["number"]} (branch: #{branch})"
+            LOG.info "[PR Track] Tracked PR ##{pr_number} on card ##{extract_card_number(card_info)} (branch: #{branch})"
           end
 
           def dispatch_pr_comment(card_number, card_key, pr_number, comment_id, comment_user, comment_body,
                                   repo_name, worktree, project_key, project_config)
             Thread.new do
-              run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/issues/comments/#{comment_id}/reactions",
-                      "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: worktree)
+              if AppClient.configured?
+                AppClient.create_comment_reaction(repo_name, comment_id, "eyes")
+              else
+                run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/issues/comments/#{comment_id}/reactions",
+                        "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: worktree)
+              end
             rescue StandardError => e
               LOG.warn "Could not add reaction to comment: #{e.message}"
             end
@@ -319,8 +348,14 @@ module Brainiac
                                  repo_name, project_key, project_config, repo_path)
             review_id = review["id"]
             Thread.new do
-              run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/pulls/reviews/#{review_id}/reactions",
-                      "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: repo_path)
+              if AppClient.configured?
+                AppClient.create_review_reaction(repo_name, review_id, "eyes")
+              else
+                run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/pulls/reviews/#{review_id}/reactions",
+                        "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: repo_path)
+              end
+
+              react_to_review_comments(review_id, pr_number, repo_name, repo_path)
             rescue StandardError => e
               LOG.warn "Could not add reaction to review: #{e.message}"
             end
@@ -369,24 +404,62 @@ module Brainiac
           end
 
           def fetch_pr_review_comments(pr_number, repo)
-            output = run_cmd("gh", "api", "/repos/#{repo}/pulls/#{pr_number}/comments",
-                             "--jq", ".[] | {path, line, body, user: .user.login}",
-                             chdir: PROJECTS.values.first&.dig("repo_path") || Dir.pwd)
-            output.lines.map { |line| JSON.parse(line) }
+            if AppClient.configured?
+              response = AppClient.get("/repos/#{repo}/pulls/#{pr_number}/comments")
+              # Response is an array of comment objects
+              response.map { |c| { "path" => c["path"], "line" => c["line"], "body" => c["body"], "user" => c.dig("user", "login") } }
+            else
+              output = run_cmd("gh", "api", "/repos/#{repo}/pulls/#{pr_number}/comments",
+                               "--jq", ".[] | {path, line, body, user: .user.login}",
+                               chdir: PROJECTS.values.first&.dig("repo_path") || Dir.pwd)
+              output.lines.map { |line| JSON.parse(line) }
+            end
           rescue StandardError => e
             LOG.warn "Could not fetch PR review comments: #{e.message}"
             []
           end
 
+          # React with 👀 to each individual comment in a review submission.
+          # This makes reactions visible on line-level file comments, not just the review wrapper.
+          def react_to_review_comments(review_id, pr_number, repo_name, repo_path)
+            if AppClient.configured?
+              comments = AppClient.get("/repos/#{repo_name}/pulls/#{pr_number}/reviews/#{review_id}/comments")
+              comment_ids = comments.map { |c| c["id"] }
+            else
+              output = run_cmd("gh", "api", "/repos/#{repo_name}/pulls/#{pr_number}/reviews/#{review_id}/comments",
+                               "--jq", ".[].id", chdir: repo_path)
+              comment_ids = output.lines.map(&:strip).reject(&:empty?)
+            end
+
+            comment_ids.each do |comment_id|
+              if AppClient.configured?
+                AppClient.create_comment_reaction(repo_name, comment_id, "eyes")
+              else
+                run_cmd("gh", "api", "-X", "POST", "/repos/#{repo_name}/pulls/comments/#{comment_id}/reactions",
+                        "-f", "content=eyes", "-H", "Accept: application/vnd.github+json", chdir: repo_path)
+              end
+            end
+          rescue StandardError => e
+            LOG.warn "Could not react to review comments: #{e.message}"
+          end
+
           # Lightweight recent PR comment context for intent classification.
           # Returns "author: message" format (last 5 issue comments on the PR).
           def fetch_pr_intent_context(pr_number, repo_name)
-            output = run_cmd("gh", "api", "/repos/#{repo_name}/issues/#{pr_number}/comments",
-                             "--jq", ".[-5:] | .[] | \"\\(.user.login): \\(.body[0:200])\"",
-                             chdir: PROJECTS.values.first&.dig("repo_path") || Dir.pwd)
-            return nil if output.strip.empty?
+            if AppClient.configured?
+              comments = AppClient.get("/repos/#{repo_name}/issues/#{pr_number}/comments")
+              entries = comments.last(5).map { |c| "#{c.dig("user", "login")}: #{c["body"]&.slice(0, 200)}" }
+              return nil if entries.empty?
 
-            output.strip
+              entries.join("\n")
+            else
+              output = run_cmd("gh", "api", "/repos/#{repo_name}/issues/#{pr_number}/comments",
+                               "--jq", ".[-5:] | .[] | \"\\(.user.login): \\(.body[0:200])\"",
+                               chdir: PROJECTS.values.first&.dig("repo_path") || Dir.pwd)
+              return nil if output.strip.empty?
+
+              output.strip
+            end
           rescue StandardError => e
             LOG.warn "[GitHub] Could not fetch intent context for PR ##{pr_number}: #{e.message}" if defined?(LOG)
             nil

data/lib/brainiac/plugins/github/version.rb

@@ -3,7 +3,7 @@
 module Brainiac
   module Plugins
     module Github
-      VERSION = "0.0.6"
+      VERSION = "0.1.0"
     end
   end
 end

data/lib/brainiac/plugins/github.rb

@@ -4,6 +4,7 @@ require_relative "github/version"
 require_relative "github/metadata"
 require_relative "github/cli"
 require_relative "github/config"
+require_relative "github/app_client"
 require_relative "github/prompts"
 require_relative "github/notifications"
 require_relative "github/handler"
@@ -68,7 +69,11 @@ module Brainiac
             comment_body = "💥 **#{agent_display} crashed** (exit code #{ctx[:exit_status]})\n\nLog: `#{ctx[:log_file]}`#{snippet_block}"
 
             begin
-              run_cmd("gh", "pr", "comment", pr_number.to_s, "--repo", repo_name, "--body", comment_body, chdir: work_dir)
+              if AppClient.configured?
+                AppClient.create_comment(repo_name, pr_number, comment_body)
+              else
+                run_cmd("gh", "pr", "comment", pr_number.to_s, "--repo", repo_name, "--body", comment_body, chdir: work_dir)
+              end
               LOG.info "[GitHub] Posted crash comment on PR ##{pr_number}"
             rescue StandardError => e
               LOG.error "[GitHub] Failed to post crash comment: #{e.message}"

data/templates/github.json.example

@@ -1,4 +1,9 @@
 {
   "webhook_secret": "your-github-webhook-secret",
+  "app": {
+    "id": "",
+    "private_key_path": "~/.brainiac/github-app-private-key.pem",
+    "installation_id": ""
+  },
   "repos": {}
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac-github
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Andy Davis
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.14
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +103,7 @@ files:
 - LICENSE
 - README.md
 - lib/brainiac/plugins/github.rb
+- lib/brainiac/plugins/github/app_client.rb
 - lib/brainiac/plugins/github/cli.rb
 - lib/brainiac/plugins/github/config.rb
 - lib/brainiac/plugins/github/handler.rb