collavre 0.2.5 → 0.3.1

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

@@ -1,280 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

data/app/services/collavre/system_events/router.rb

@@ -1,96 +0,0 @@
-module Collavre
-  module SystemEvents
-    class Router
-      def route(event_name, context)
-        # Build the context for Liquid
-        liquid_context = Collavre::SystemEvents::ContextBuilder.new(context).build
-        liquid_context["event_name"] = event_name
-
-        # Priority 1: Mention-based routing (exclusive)
-        # If any user is mentioned, mention routing takes over exclusively.
-        # - Mentioned AI agent → route only to that agent
-        # - Mentioned non-AI user → route to nobody (no AI agents)
-        mentioned_result = find_mentioned_routing(liquid_context, context)
-        return mentioned_result unless mentioned_result.nil?
-
-        # Priority 2: Liquid expression routing (fallback, only when no mention)
-        route_by_liquid_expression(liquid_context, context)
-      end
-
-      private
-
-      # Returns Array of agents to route to, or nil if no mention was found.
-      # When a mention IS found, this is exclusive:
-      #   - AI agent mentioned → [agent] (if permitted)
-      #   - Non-AI user mentioned → [] (no AI agents should receive it)
-      def find_mentioned_routing(liquid_context, context)
-        mentioned_user_data = liquid_context.dig("chat", "mentioned_user")
-        return nil unless mentioned_user_data && mentioned_user_data["id"]
-
-        mentioned_user = User.find_by(id: mentioned_user_data["id"])
-        return nil unless mentioned_user
-
-        # Mention found — this is exclusive routing.
-        # If the mentioned user is not an AI agent, no AI agents should receive the message.
-        return [] unless mentioned_user.ai_user?
-
-        # Permission check for mentioned AI agent
-        return [] unless has_creative_permission?(mentioned_user, context)
-
-        [ mentioned_user ]
-      end
-
-      def route_by_liquid_expression(liquid_context, context)
-        # Find all AI agents
-        agents = User.where.not(llm_vendor: nil)
-
-        matched_agents = []
-
-        agents.each do |agent|
-          next if agent.routing_expression.blank?
-
-          # Permission Check
-          next unless has_creative_permission?(agent, context)
-
-          begin
-            # Add 'agent' to context so they can refer to themselves
-            agent_context = liquid_context.merge("agent" => agent.as_json(only: [ :id, :name, :email ]))
-
-            # Parse and evaluate the routing expression
-            # We wrap the expression in an if block to evaluate truthiness
-            expression = agent.routing_expression.strip
-            unless expression.start_with?("{%")
-              expression = "{% if #{expression} %}true{% endif %}"
-            end
-
-            template = Liquid::Template.parse(expression)
-            result = template.render(agent_context)
-
-            # Check if the result evaluates to "true" string or boolean true
-            if result.strip == "true"
-              matched_agents << agent
-            end
-          rescue StandardError => e
-            Rails.logger.error("Routing error for agent #{agent.id}: #{e.message}")
-          end
-        end
-
-        matched_agents
-      end
-
-      def has_creative_permission?(agent, context)
-        # Searchable agents can receive any routed message
-        return true if agent.searchable?
-
-        # Non-searchable agents must have feedback permission on the creative
-        creative_id = context.dig("creative", "id") || context.dig(:creative, :id)
-        return false unless creative_id
-
-        creative = Creative.find_by(id: creative_id)
-        return false unless creative
-
-        creative.has_permission?(agent, :feedback)
-      end
-    end
-  end
-end