collavre 0.1.0

data/app/services/collavre/github/pull_request_analyzer.rb

@@ -0,0 +1,280 @@
+module Collavre
+  require "json"
+
+  module Github
+    class PullRequestAnalyzer
+      Result = Struct.new(:completed, :additional, :raw_response, :prompt, keyword_init: true)
+      CompletedTask = Struct.new(:creative_id, :progress, :note, :path, keyword_init: true)
+      SuggestedTask = Struct.new(:parent_id, :description, :progress, :note, :path, keyword_init: true)
+
+      DIFF_MAX_LENGTH = 10_000
+
+      def initialize(payload:, creative:, paths:, commit_messages: [], diff: nil, client: default_client, logger: Rails.logger)
+        @payload = payload
+        @creative = creative
+        @paths = normalize_paths(paths)
+        @commit_messages = Array(commit_messages)
+        @diff = diff
+        @client = client
+        @logger = logger
+        @prompt_text = nil
+      end
+
+      def call
+        response_text = collect_response
+        return unless response_text.present?
+
+        parsed = parse_response(response_text)
+        Result.new(
+          completed: parsed[:completed],
+          additional: parsed[:additional],
+          raw_response: response_text,
+          prompt: prompt_text
+        )
+      rescue StandardError => e
+        logger.error("Gemini analysis failed: #{e.class} #{e.message}")
+        nil
+      end
+
+      private
+
+      attr_reader :payload, :creative, :paths, :commit_messages, :diff, :client, :logger, :prompt_text
+
+      def collect_response
+        messages = build_messages
+        buffer = +""
+        client.chat(messages) do |delta|
+          buffer << delta.to_s
+        end
+        buffer
+      rescue StandardError => e
+        logger.error("Gemini chat failed: #{e.class} #{e.message}")
+        nil
+      end
+
+      def default_client
+        AiClient.new(
+          vendor: "google",
+          model: "gemini-2.5-flash",
+          system_prompt: AiClient::SYSTEM_INSTRUCTIONS
+        )
+      end
+
+      def build_messages
+        pr = payload["pull_request"]
+
+        # Use shared TreeFormatter logic
+        tree_lines = Creatives::TreeFormatter.new.format(creative)
+
+        pr_body = pr["body"].to_s
+        commit_lines = formatted_commit_messages
+        diff_text = formatted_diff
+        language_instructions = preferred_language_instructions
+
+        prompt_template = creative.github_gemini_prompt_template
+        prompt = render_prompt_template(
+          prompt_template,
+          pr_title: pr["title"].to_s,
+          pr_body: pr_body,
+          commit_messages: commit_lines,
+          diff: diff_text,
+          creative_tree: tree_lines,
+          language_instructions: language_instructions
+        )
+
+        @prompt_text = prompt
+        [ { role: "user", parts: [ { text: prompt } ] } ]
+      end
+
+      def normalize_paths(paths)
+        Array(paths).map do |entry|
+          case entry
+          when Hash
+            path_value = entry[:path]
+            path_value = entry["path"] if path_value.nil?
+
+            leaf_value =
+              if entry.key?(:leaf)
+                entry[:leaf]
+              elsif entry.key?("leaf")
+                entry["leaf"]
+              end
+
+            {
+              path: path_value.to_s,
+              leaf: !!leaf_value
+            }
+          else
+            { path: entry.to_s, leaf: false }
+          end
+        end
+      end
+
+      def parse_response(text)
+        json_fragment = extract_json(text)
+        data = JSON.parse(json_fragment)
+        {
+          completed: sanitize_completed(data["completed"]),
+          additional: sanitize_additional(data["additional"])
+        }
+      rescue JSON::ParserError => e
+        logger.warn("Failed to parse Gemini response as JSON: #{e.message}")
+        { completed: [], additional: [] }
+      end
+
+      def extract_json(text)
+        start_index = text.index("{")
+        end_index = text.rindex("}")
+        return text unless start_index && end_index && end_index >= start_index
+
+        text[start_index..end_index]
+      end
+
+      def formatted_commit_messages
+        return "No commit messages available." if commit_messages.blank?
+
+        commit_messages.map.with_index(1) do |message, index|
+          "#{index}. #{message.to_s.strip}"
+        end.join("\n")
+      end
+
+      def formatted_diff
+        return "(No diff available)" if diff.blank?
+
+        diff_text = diff.to_s.strip
+        return "(No diff available)" if diff_text.empty?
+
+        return diff_text if diff_text.length <= DIFF_MAX_LENGTH
+
+        truncated = diff_text.slice(0, DIFF_MAX_LENGTH)
+        "#{truncated}\n...\n[Diff truncated to #{DIFF_MAX_LENGTH} characters]"
+      end
+
+      def preferred_language_instructions
+        language = preferred_response_language
+        "Preferred response language: #{language[:label]} (#{language[:code]}). Write all natural-language output, including new creative descriptions, in #{language[:label]}."
+      end
+
+      def preferred_response_language
+        locale = creative.user&.locale.presence
+        locale ||= I18n.default_locale.to_s if defined?(I18n)
+        locale ||= "en"
+
+        label = if defined?(I18n)
+                  I18n.t("collavre.users.locales.#{locale}", default: locale)
+        else
+                  locale
+        end
+
+        { code: locale, label: label }
+      end
+
+      def render_prompt_template(template, variables)
+        template.to_s.gsub(/\#\{([^}]+)\}/) do
+          key = Regexp.last_match(1).strip.to_sym
+          value = variables.fetch(key, "")
+          value.to_s
+        end
+      end
+
+      def sanitize_completed(items)
+        Array(items).filter_map do |item|
+          case item
+          when Hash
+            creative_id = extract_creative_id(item["creative_id"] || item["id"])
+            next unless creative_id
+
+            CompletedTask.new(
+              creative_id: creative_id,
+              progress: normalize_progress(item["progress"], default: 1.0),
+              note: string_presence(item["note"] || item["summary"]),
+              path: string_presence(item["path"] || item["description"])
+            )
+          when Integer
+            CompletedTask.new(creative_id: item, progress: 1.0)
+          when String
+            creative_id = extract_id_from_string(item)
+            next unless creative_id
+
+            CompletedTask.new(
+              creative_id: creative_id,
+              progress: 1.0,
+              path: string_presence(item)
+            )
+          else
+            nil
+          end
+        end
+      end
+
+      def sanitize_additional(items)
+        Array(items).filter_map do |item|
+          case item
+          when Hash
+            parent_id = extract_creative_id(item["parent_id"] || item["parent"])
+            description = string_presence(item["description"] || item["title"])
+            next unless parent_id && description
+
+            SuggestedTask.new(
+              parent_id: parent_id,
+              description: description,
+              progress: normalize_progress(item["progress"], default: nil),
+              note: string_presence(item["note"] || item["summary"]),
+              path: string_presence(item["path"])
+            )
+          when String
+            parent_id = extract_id_from_string(item)
+            next unless parent_id
+
+            description = item.sub(/^.*\]\s*/, "").strip
+            description = item if description.blank?
+
+            SuggestedTask.new(parent_id: parent_id, description: description, progress: nil)
+          else
+            nil
+          end
+        end
+      end
+
+      def extract_creative_id(value)
+        case value
+        when Integer
+          value.positive? ? value : nil
+        when Float
+          int_value = value.to_i
+          int_value.positive? ? int_value : nil
+        when String
+          match = value.match(/\d+/)
+          match ? match[0].to_i : nil
+        else
+          nil
+        end
+      end
+
+      def normalize_progress(value, default: nil)
+        return default if value.nil?
+
+        float_value = Float(value) rescue nil
+        return default unless float_value
+
+        [ [ float_value, 0.0 ].max, 1.0 ].min
+      end
+
+      def string_presence(value)
+        return if value.nil?
+
+        str = value.to_s.strip
+        str.presence
+      end
+
+      def extract_id_from_string(value)
+        return unless value.is_a?(String)
+
+        matches = value.scan(/\[(\d+)\]/).flatten
+        return if matches.blank?
+
+        matches.last.to_i
+      end
+    end
+  end
+end

data/app/services/collavre/github/pull_request_processor.rb

@@ -0,0 +1,181 @@
+module Collavre
+  require "json"
+
+  module Github
+    class PullRequestProcessor
+      HANDLED_ACTIONS = %w[closed].freeze
+
+      def initialize(payload:, logger: Rails.logger)
+        @payload = payload
+        @logger = logger
+      end
+
+      def call
+        action = payload["action"]
+        return unless HANDLED_ACTIONS.include?(action)
+
+        pr = payload["pull_request"]
+        return unless pr
+        return unless pr["merged"]
+
+        repo_full_name = payload.dig("repository", "full_name")
+        return unless repo_full_name
+
+        links = GithubRepositoryLink.includes(:creative).where(repository_full_name: repo_full_name)
+        return if links.blank?
+
+        links.each do |link|
+          process_link(link)
+        end
+      rescue StandardError => e
+        logger.error("GitHub PR processing failed: #{e.class} #{e.message}")
+      end
+
+      private
+
+      attr_reader :payload, :logger
+
+      def process_link(link)
+        creative = link.creative.effective_origin
+        path_exporter = Creatives::PathExporter.new(creative, use_effective_origin: false)
+        tree_entries = path_exporter.full_paths_with_ids_and_progress_with_leaf
+        return if tree_entries.blank?
+
+        repo_full_name = payload.dig("repository", "full_name")
+        pr = payload["pull_request"]
+        client = Github::Client.new(link.github_account)
+        commit_messages = client.pull_request_commit_messages(repo_full_name, pr["number"])
+        diff = client.pull_request_diff(repo_full_name, pr["number"])
+
+        analyzer = Github::PullRequestAnalyzer.new(
+          payload: payload,
+          creative: creative,
+          paths: tree_entries,
+          commit_messages: commit_messages,
+          diff: diff
+        )
+        result = analyzer.call
+        return unless result
+
+        create_comment(creative, link, path_exporter, result)
+      end
+
+      def create_comment(creative, link, path_exporter, result)
+        pr = payload["pull_request"]
+        title = pr["title"]
+        number = pr["number"]
+        url = pr["html_url"]
+
+        lines = []
+        lines << "### Github PR 분석"
+        lines << "- PR: [##{number} #{title}](#{url})"
+        lines << ""
+        lines << "#### 완료된 Creative"
+        if result.completed.any?
+          result.completed.each do |task|
+            lines << "- #{format_completed_task(task, path_exporter)}"
+          end
+        else
+          lines << "- 없음"
+        end
+        lines << ""
+        lines << "#### 추가로 필요한 Creative"
+        if result.additional.any?
+          result.additional.each do |suggestion|
+            lines << "- #{format_suggestion(suggestion, path_exporter)}"
+          end
+        else
+          lines << "- 없음"
+        end
+
+        actions = build_actions(result)
+        if actions.any?
+          lines << ""
+          lines << "#### 승인 시 자동 적용"
+          lines << "- 이 댓글을 승인하면 완료된 Creative의 진행률이 업데이트되고 제안된 Creative가 생성됩니다."
+        end
+
+        attributes = { user: nil, content: lines.join("\n") }
+        if actions.any?
+          approver = link.github_account.user
+          if approver
+            attributes[:action] = JSON.pretty_generate({ actions: actions })
+            attributes[:approver] = approver
+          else
+            logger.warn("Skipping action assignment for PR comment because approver is missing")
+          end
+        end
+
+        creative.comments.create!(attributes)
+      end
+
+      def build_actions(result)
+        actions = []
+
+        result.completed.each do |task|
+          next unless task.creative_id
+
+          actions << {
+            "action" => "update_creative",
+            "creative_id" => task.creative_id,
+            "attributes" => {
+              "progress" => (task.progress || 1.0).to_f
+            }
+          }
+        end
+
+        result.additional.each do |suggestion|
+          next unless suggestion.parent_id && suggestion.description.present?
+
+          attributes = { "description" => suggestion.description }
+          attributes["progress"] = suggestion.progress.to_f if suggestion.progress
+
+          actions << {
+            "action" => "create_creative",
+            "parent_id" => suggestion.parent_id,
+            "attributes" => attributes
+          }
+        end
+
+        actions
+      end
+
+      def format_completed_task(task, path_exporter)
+        label = task.path.presence || path_exporter.path_for(task.creative_id) || "Creative ##{task.creative_id}"
+        parts = []
+        parts << "#{creative_link(task.creative_id)} #{label}"
+        if task.progress && task.progress < 1.0
+          percentage = (task.progress * 100).round
+          parts << "(progress #{percentage}%)"
+        end
+        parts << task.note if task.note.present?
+        parts.join(" ")
+      end
+
+      def format_suggestion(suggestion, path_exporter)
+        parent_label = path_exporter.path_for(suggestion.parent_id) || "Creative ##{suggestion.parent_id}"
+        parts = []
+        parts << "#{creative_link(suggestion.parent_id)} #{parent_label}"
+        parts << "→ #{suggestion.description}"
+        if suggestion.progress
+          percentage = (suggestion.progress * 100).round
+          parts << "(initial progress #{percentage}%)"
+        end
+        parts << "- #{suggestion.note}" if suggestion.note.present?
+        parts.join(" ")
+      end
+
+      def creative_link(id)
+        path = url_helpers.creative_path(id)
+        "[#%<id>d](%<path>s)" % { id: id, path: path }
+      rescue StandardError => e
+        logger.warn("Failed to build creative link for ##{id}: #{e.message}")
+        "##{id}"
+      end
+
+      def url_helpers
+        @url_helpers ||= Collavre::Engine.routes.url_helpers
+      end
+    end
+  end
+end

data/app/services/collavre/github/webhook_provisioner.rb

@@ -0,0 +1,130 @@
+module Collavre
+  module Github
+    class WebhookProvisioner
+      EVENTS = %w[pull_request].freeze
+      CONTENT_TYPE = "json".freeze
+
+      def self.ensure_for_links(account:, links:, webhook_url:)
+        new(account: account, webhook_url: webhook_url).ensure_for_links(Array(links))
+      end
+
+      def self.remove_for_repositories(account:, repositories:, webhook_url:)
+        new(account: account, webhook_url: webhook_url).remove_for_repositories(Array(repositories))
+      end
+
+      def initialize(account:, webhook_url:, client: Github::Client.new(account))
+        @client = client
+        @webhook_url = webhook_url
+      end
+
+      def ensure_for_links(links)
+        links.each do |link|
+          ensure_webhook(link)
+        end
+      end
+
+      def remove_for_repositories(repositories)
+        repositories.each do |repository_full_name|
+          next if GithubRepositoryLink.where(repository_full_name: repository_full_name).exists?
+
+          remove_webhook(repository_full_name)
+        end
+      end
+
+      private
+
+      attr_reader :client, :webhook_url
+
+      def ensure_webhook(link)
+        repository_full_name = link.repository_full_name
+        primary_link = primary_link_for(repository_full_name)
+        hook = find_existing_hook(repository_full_name)
+
+        if hook
+          if primary_link && primary_link != link
+            align_link_secret(link, primary_link.webhook_secret)
+          else
+            update_webhook(repository_full_name, hook.id, link.webhook_secret)
+          end
+        else
+          secret = link.webhook_secret
+
+          if primary_link && primary_link != link
+            secret = primary_link.webhook_secret
+            align_link_secret(link, secret)
+          end
+
+          create_webhook(repository_full_name, secret)
+        end
+      rescue Octokit::Error => e
+        Rails.logger.warn(
+          "GitHub webhook provisioning failed for #{repository_full_name}: #{e.message}"
+        )
+      end
+
+      def remove_webhook(repository_full_name)
+        hook = find_existing_hook(repository_full_name)
+        return unless hook
+
+        client.delete_repository_webhook(repository_full_name, hook.id)
+      rescue Octokit::Error => e
+        Rails.logger.warn(
+          "GitHub webhook removal failed for #{repository_full_name}: #{e.message}"
+        )
+      end
+
+      def find_existing_hook(repository_full_name)
+        client.repository_hooks(repository_full_name).find do |hook|
+          config = normalize_config(hook.config)
+          config["url"] == webhook_url
+        end
+      end
+
+      def create_webhook(repository_full_name, secret)
+        client.create_repository_webhook(
+          repository_full_name,
+          url: webhook_url,
+          secret: secret,
+          events: EVENTS,
+          content_type: CONTENT_TYPE
+        )
+      end
+
+      def update_webhook(repository_full_name, hook_id, secret)
+        client.update_repository_webhook(
+          repository_full_name,
+          hook_id,
+          url: webhook_url,
+          secret: secret,
+          events: EVENTS,
+          content_type: CONTENT_TYPE
+        )
+      end
+
+      def primary_link_for(repository_full_name)
+        GithubRepositoryLink
+          .where(repository_full_name: repository_full_name)
+          .order(:id)
+          .first
+      end
+
+      def align_link_secret(link, secret)
+        return if secret.blank? || link.webhook_secret == secret
+
+        link.update!(webhook_secret: secret)
+      end
+
+      def normalize_config(config)
+        hash =
+          case config
+          when Hash
+            config
+          else
+            config.respond_to?(:to_h) ? config.to_h : {}
+          end
+
+        hash.with_indifferent_access
+      end
+    end
+  end
+end