collavre_github 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6e34dfe63b704291f75021325bbd14373f550306cacc75659357fd014fe43f39
+  data.tar.gz: a5c250dbbbbac3307e1a25fe2850de5597f0ca034c16b1768f41afc46dc6550a
+SHA512:
+  metadata.gz: d79519c6b6486d4cc80e4a9d306aff4b14416f8f8610bc63ec968d6b69c2a581bc3ba350bc4b83e3bfa58584175923a94ab14b453de5a96f209df11b56fa2bf0
+  data.tar.gz: c5a798233218d63d8c5662be0d280e70010bccbc29474d194318d088645170be0a2d5c9cedc3458985003b2a3ca39e41d40b2e4455835d460f8d67f2292142d8

data/README.md

@@ -0,0 +1,127 @@
+# Collavre GitHub
+
+GitHub integration engine for Collavre.
+
+## Features
+
+- OAuth authentication with GitHub
+- Repository linking to Creatives
+- Webhook → System Comment automatic creation
+- **MCP Tools** for AI Agents to analyze PRs
+- **Seed AI Agent**: GitHub PR Analyzer
+
+## Architecture
+
+```
+GitHub Webhook (push, pull_request, etc.)
+     │
+     ▼
+System Comment created in linked Creative
+     │
+     ▼
+comment_created event dispatched
+     │
+     ▼
+AI Agent (GitHub PR Analyzer) triggered
+     │
+     ├── github_pr_details - Get PR info
+     ├── github_pr_diff - Get code changes
+     ├── github_pr_commits - Get commit messages
+     └── creative_retrieval_service - Get task tree
+     │
+     ▼
+Action Comment response (JSON format)
+     │
+     ▼
+User approval → Creative updates
+```
+
+## MCP Tools
+
+Tools for AI Agents to interact with GitHub:
+
+| Tool | Description |
+|------|-------------|
+| `github_pr_details` | Get PR title, body, author, files, additions/deletions |
+| `github_pr_diff` | Get PR diff with truncation support (default: 10K chars) |
+| `github_pr_commits` | Get list of commit messages in the PR |
+
+### Tool Parameters
+
+All tools require:
+- `creative_id` - The Creative with GitHub integration
+- `repo` - Repository full name (e.g., `owner/repo`)
+- `pr_number` - Pull request number
+
+The tools automatically find the GitHub account through:
+```
+Creative → RepositoryLink → GithubAccount → GitHub API
+```
+
+## Seed AI Agent
+
+Running `rails db:seed` creates the **GitHub PR Analyzer** agent:
+
+- **Name**: GitHub PR Analyzer
+- **Email**: `github-pr-analyzer@collavre.local`
+- **Trigger**: GitHub PR merged events (system comments)
+- **Tools**: github_pr_details, github_pr_diff, github_pr_commits, creative_retrieval_service, creative_update_service
+- **Output**: Action comments for updating Creative progress
+
+### Routing Expression
+
+```liquid
+event_name == "comment_created" and chat.comment.user_id == nil and chat.comment.content contains "GitHub: Pull Request merged"
+```
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "collavre_github", path: "engines/collavre_github"
+```
+
+## Configuration
+
+### OAuth Setup
+
+1. Create a GitHub OAuth App at https://github.com/settings/developers
+2. Set callback URL to: `https://your-domain.com/auth/github/callback`
+3. Add credentials:
+
+```bash
+bin/rails credentials:edit
+```
+
+```yaml
+github:
+  client_id: your_client_id
+  client_secret: your_client_secret
+  webhook_secret: optional_fallback_secret
+```
+
+### OmniAuth Configuration
+
+In `config/initializers/omniauth.rb`:
+
+```ruby
+Rails.application.config.middleware.use OmniAuth::Builder do
+  provider :github,
+           Rails.application.credentials.dig(:github, :client_id),
+           Rails.application.credentials.dig(:github, :client_secret),
+           scope: "repo,read:org"
+end
+```
+
+## Usage
+
+1. Connect GitHub account via OAuth
+2. Link repository to a Creative
+3. Webhook events automatically create system comments
+4. AI Agent analyzes PRs and suggests task updates
+5. User approves action comments to update Creatives
+
+## License
+
+AGPL

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/controllers/collavre_github/accounts_controller.rb

@@ -0,0 +1,84 @@
+module CollavreGithub
+  class AccountsController < ApplicationController
+    before_action :require_account
+
+    def show
+      render json: serialize_account(Current.user.github_account)
+    end
+
+    def organizations
+      orgs = github_client.organizations.map do |org|
+        {
+          id: org[:id] || org["id"],
+          login: org[:login] || org["login"],
+          name: org[:name] || org["name"] || (org[:login] || org["login"]),
+          type: org[:type] || org["type"]
+        }
+      end
+
+      user_org = {
+        id: Current.user.github_account.github_uid,
+        login: Current.user.github_account.login,
+        name: Current.user.github_account.name.presence || Current.user.github_account.login,
+        type: "User"
+      }
+
+      render json: { organizations: [ user_org ] + orgs }
+    rescue Octokit::Unauthorized
+      render json: { error: "unauthorized" }, status: :unauthorized
+    end
+
+    def repositories
+      organization = params[:organization]
+      creative = params[:creative_id].present? ? Collavre::Creative.find_by(id: params[:creative_id]) : nil
+      selected = if creative
+        creative.github_repository_links.where(github_account: Current.user.github_account)
+                .pluck(:repository_full_name)
+      else
+        []
+      end
+
+      repos = fetch_repositories(organization).map do |repo|
+        full_name = repo[:full_name] || repo["full_name"]
+        {
+          id: repo[:id] || repo["id"],
+          name: repo[:name] || repo["name"],
+          full_name: full_name,
+          selected: selected.include?(full_name)
+        }
+      end
+
+      render json: { repositories: repos }
+    rescue Octokit::NotFound
+      render json: { error: "not_found" }, status: :not_found
+    end
+
+    private
+
+    def serialize_account(account)
+      {
+        login: account.login,
+        name: account.name,
+        avatar_url: account.avatar_url
+      }
+    end
+
+    def require_account
+      return if Current.user.github_account
+
+      render json: { connected: false, error: "not_connected" }, status: :unprocessable_entity
+    end
+
+    def github_client
+      @github_client ||= CollavreGithub::Client.new(Current.user.github_account)
+    end
+
+    def fetch_repositories(organization)
+      if organization.blank? || organization == Current.user.github_account.login
+        github_client.repositories_for_authenticated_user
+      else
+        github_client.repositories_for_organization(organization)
+      end
+    end
+  end
+end

data/app/controllers/collavre_github/application_controller.rb

@@ -0,0 +1,11 @@
+module CollavreGithub
+  class ApplicationController < ::ApplicationController
+    private
+
+    def github_webhook_url
+      CollavreGithub::Engine.routes.url_helpers.webhooks_url(
+        Rails.application.config.action_mailer.default_url_options
+      )
+    end
+  end
+end

data/app/controllers/collavre_github/auth_controller.rb

@@ -0,0 +1,27 @@
+module CollavreGithub
+  class AuthController < ApplicationController
+    allow_unauthenticated_access only: :callback
+    before_action -> { enforce_auth_provider!(:github) }, only: :callback
+
+    def callback
+      auth = request.env["omniauth.auth"]
+      account = CollavreGithub::Account.find_or_initialize_by(github_uid: auth.uid)
+
+      if account.new_record?
+        unless Current.user
+          redirect_to collavre.new_session_path, alert: I18n.t("collavre_github.auth.login_first")
+          return
+        end
+        account.user_id = Current.user.id
+      end
+
+      account.token = auth.credentials.token
+      account.login = auth.info.nickname
+      account.name = auth.info.name
+      account.avatar_url = auth.info.image
+      account.save!
+
+      redirect_to collavre.creatives_path, notice: I18n.t("collavre_github.auth.connected")
+    end
+  end
+end

data/app/controllers/collavre_github/creatives/integrations_controller.rb

@@ -0,0 +1,181 @@
+module CollavreGithub
+  module Creatives
+    class IntegrationsController < ApplicationController
+      before_action :set_creative
+      before_action :ensure_read_permission
+      before_action :ensure_admin_permission, only: [ :show, :update ]
+
+      def show
+        account = Current.user.github_account
+        links = linked_repository_links(account)
+
+        render json: {
+          connected: account.present?,
+          account: account && {
+            login: account.login,
+            name: account.name,
+            avatar_url: account.avatar_url
+          },
+          selected_repositories: links.map(&:repository_full_name),
+          webhooks: serialize_webhooks(links),
+          github_gemini_prompt: @creative.github_gemini_prompt_template
+        }
+      end
+
+      def update
+        account = Current.user.github_account
+        unless account
+          render json: { error: I18n.t("collavre_github.errors.not_connected") }, status: :unprocessable_entity
+          return
+        end
+
+        integration_attributes = integration_params
+        repositories = Array(integration_attributes[:repositories]).map(&:to_s).uniq
+        prompt_param = integration_attributes[:github_gemini_prompt] if integration_attributes.key?(:github_gemini_prompt)
+
+        links = nil
+
+        CollavreGithub::RepositoryLink.transaction do
+          linked_repository_links(account)
+            .where.not(repository_full_name: repositories)
+            .delete_all
+
+          repositories.each do |full_name|
+            @creative.github_repository_links.find_or_create_by!(
+              github_account: account,
+              repository_full_name: full_name
+            )
+          end
+
+          links = linked_repository_links(account).to_a
+
+          if prompt_param
+            @creative.update!(github_gemini_prompt: prompt_param.presence)
+          end
+        end
+
+        CollavreGithub::WebhookProvisioner.ensure_for_links(
+          account: account,
+          links: links,
+          webhook_url: github_webhook_url
+        ) if links.present?
+
+        render json: {
+          success: true,
+          selected_repositories: links.map(&:repository_full_name),
+          webhooks: serialize_webhooks(links),
+          github_gemini_prompt: @creative.github_gemini_prompt_template
+        }
+      rescue ActiveRecord::RecordInvalid => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      end
+
+      def destroy
+        unless @creative.has_permission?(Current.user, :write)
+          render json: { error: I18n.t("collavre_github.errors.forbidden") }, status: :forbidden
+          return
+        end
+
+        account = Current.user.github_account
+        unless account
+          render json: { error: I18n.t("collavre_github.errors.not_connected") }, status: :unprocessable_entity
+          return
+        end
+
+        repositories = Array(params[:repositories]).filter_map { |value| value.to_s.presence }
+        repository = params[:repository].presence || params[:repository_full_name].presence
+
+        scope = linked_repository_links(account)
+
+        removed_repositories = []
+
+        if repositories.present?
+          links_to_remove = scope.where(repository_full_name: repositories).to_a
+          missing_repositories = repositories - links_to_remove.map(&:repository_full_name)
+          if missing_repositories.present?
+            render json: { error: I18n.t("collavre_github.errors.not_found") }, status: :not_found
+            return
+          end
+
+          CollavreGithub::RepositoryLink.transaction do
+            removed_repositories = links_to_remove.map(&:repository_full_name)
+            links_to_remove.each(&:destroy!)
+          end
+        elsif repository
+          link = scope.find_by(repository_full_name: repository)
+          unless link
+            render json: { error: I18n.t("collavre_github.errors.not_found") }, status: :not_found
+            return
+          end
+
+          CollavreGithub::RepositoryLink.transaction do
+            removed_repositories = [ link.repository_full_name ]
+            link.destroy!
+          end
+        else
+          CollavreGithub::RepositoryLink.transaction do
+            removed_repositories = scope.pluck(:repository_full_name)
+            scope.destroy_all
+          end
+        end
+
+        if removed_repositories.present?
+          CollavreGithub::WebhookProvisioner.remove_for_repositories(
+            account: account,
+            repositories: removed_repositories,
+            webhook_url: github_webhook_url
+          )
+        end
+
+        links = linked_repository_links(account)
+
+        render json: {
+          success: true,
+          selected_repositories: links.pluck(:repository_full_name),
+          webhooks: serialize_webhooks(links),
+          github_gemini_prompt: @creative.github_gemini_prompt_template
+        }
+      end
+
+      private
+
+      def set_creative
+        @creative = Collavre::Creative.find(params[:creative_id])
+      end
+
+      def ensure_read_permission
+        return if @creative.has_permission?(Current.user, :read)
+
+        render json: { error: I18n.t("collavre_github.errors.forbidden") }, status: :forbidden
+      end
+
+      def ensure_admin_permission
+        return if @creative.has_permission?(Current.user, :admin)
+
+        render json: { error: I18n.t("collavre_github.errors.forbidden") }, status: :forbidden
+      end
+
+      def linked_repository_links(account)
+        return CollavreGithub::RepositoryLink.none unless account
+
+        @creative.github_repository_links.where(github_account: account)
+      end
+
+      def integration_params
+        params.permit(:github_gemini_prompt, repositories: [])
+      end
+
+      def serialize_webhooks(links)
+        return {} if links.blank?
+
+        url = github_webhook_url
+        links.each_with_object({}) do |link, hash|
+          hash[link.repository_full_name] = {
+            url: url,
+            secret: link.webhook_secret
+          }
+        end
+      end
+    end
+  end
+end