collavre 0.1.0

data/app/services/collavre/creatives/tree_builder.rb

@@ -0,0 +1,231 @@
+module Collavre
+module Creatives
+  class TreeBuilder
+    FILTER_IGNORED_KEYS = %w[id controller action format level select_mode].freeze
+
+    def initialize(user:, params:, view_context:, expanded_state_map:, select_mode:, max_level:, allowed_creative_ids: nil, progress_map: nil)
+      @user = user
+      @view_context = view_context
+      @raw_params = params.respond_to?(:to_unsafe_h) ? params.to_unsafe_h : params.to_h
+      @expanded_state_map = expanded_state_map || {}
+      @select_mode = select_mode
+      @max_level = max_level
+      @allowed_creative_ids = allowed_creative_ids
+      @progress_map = progress_map
+      @permission_cache = {}
+    end
+
+    def build(collection, level: 1)
+      return [] if collection.blank?
+
+      creatives = Array(collection)
+      # Preload permissions for all creatives in this batch to avoid N+1
+      preload_permissions(creatives)
+
+      build_nodes(creatives, level: level)
+    end
+
+    private
+
+    attr_reader :user, :view_context, :raw_params, :expanded_state_map, :select_mode, :max_level, :allowed_creative_ids, :progress_map, :permission_cache
+
+    def preload_permissions(creatives)
+      return unless user
+
+      creative_ids = creatives.map(&:id)
+      return if creative_ids.empty?
+
+      # Skip if already cached
+      uncached_ids = creative_ids - @permission_cache.keys
+      return if uncached_ids.empty?
+
+      write_rank = CreativeShare.permissions[:write]
+
+      # Batch query for user-specific permissions
+      user_permissions = CreativeSharesCache
+        .where(creative_id: uncached_ids, user_id: user.id)
+        .pluck(:creative_id, :permission)
+
+      user_permissions.each do |cid, perm|
+        perm_rank = CreativeSharesCache.permissions[perm]
+        @permission_cache[cid] = perm_rank && perm_rank >= write_rank && perm_rank != CreativeSharesCache.permissions[:no_access]
+      end
+
+      # For remaining uncached, check public shares
+      still_uncached = uncached_ids - @permission_cache.keys
+      if still_uncached.any?
+        public_permissions = CreativeSharesCache
+          .where(creative_id: still_uncached, user_id: nil)
+          .pluck(:creative_id, :permission)
+
+        public_permissions.each do |cid, perm|
+          next if @permission_cache.key?(cid)
+          perm_rank = CreativeSharesCache.permissions[perm]
+          @permission_cache[cid] = perm_rank && perm_rank >= write_rank && perm_rank != CreativeSharesCache.permissions[:no_access]
+        end
+      end
+
+      # Mark owned creatives as having write permission
+      owned_ids = creatives.select { |c| c.user_id == user.id }.map(&:id)
+      owned_ids.each { |cid| @permission_cache[cid] = true }
+
+      # Default to false for any remaining uncached
+      uncached_ids.each { |cid| @permission_cache[cid] ||= false }
+    end
+
+    def cached_can_write?(creative)
+      return false unless user
+
+      if @permission_cache.key?(creative.id)
+        @permission_cache[creative.id]
+      else
+        # Fallback to individual check if not cached
+        creative.has_permission?(user, :write)
+      end
+    end
+
+    def build_nodes(creatives, level:)
+      return [] if level > max_level
+
+      # Preload permissions for this batch of creatives
+      preload_permissions(creatives) if creatives.any?
+
+      creatives.flat_map do |creative|
+        build_nodes_for_creative(creative, level: level)
+      end
+    end
+
+    def build_nodes_for_creative(creative, level:)
+      if progress_map && progress_map.key?(creative.id.to_s)
+        creative.filtered_progress = progress_map[creative.id.to_s]
+      end
+
+      filtered_children = filtered_children_for(creative)
+      expanded = expanded?(creative.id)
+      skip = skip_creative?(creative)
+      child_level = level + 1
+      child_render_level = skip ? level : child_level
+      load_children_now = filters_applied? || expanded || skip
+      children_nodes = load_children_now ? build_nodes(filtered_children, level: child_render_level) : []
+
+      return children_nodes if skip
+
+      [
+        {
+          id: creative.id,
+          dom_id: "creative-#{creative.id}",
+          parent_id: creative.parent_id,
+          level: level,
+          select_mode: !!select_mode,
+          can_write: cached_can_write?(creative),
+          has_children: filtered_children.any?,
+          expanded: expanded,
+          is_root: creative.parent.nil?,
+          link_url: view_context.collavre.creative_path(creative),
+          templates: template_payload_for(creative),
+          inline_editor_payload: inline_editor_payload_for(creative),
+          children_container: children_container_payload(
+            creative,
+            filtered_children,
+            child_level: child_level,
+            children_nodes: children_nodes,
+            expanded: expanded,
+            load_children_now: load_children_now
+          )
+        }
+      ]
+    end
+
+    def skip_creative?(creative)
+      # With FilterPipeline, allowed_creative_ids contains all creatives that should be shown
+      # (matched items + their ancestors). No need for duplicate filter logic here.
+      return !allowed_creative_ids.include?(creative.id.to_s) if allowed_creative_ids
+
+      false
+    end
+
+    def filtered_children_for(creative)
+      return [] if raw_params["comment"] == "true" || raw_params["search"].present?
+
+      children = creative.children_with_permission(user)
+      if allowed_creative_ids
+        children.select { |c| allowed_creative_ids.include?(c.id.to_s) }
+      else
+        children
+      end
+    end
+
+    def expanded?(creative_id)
+      expanded_state_map[creative_id.to_s].present?
+    end
+
+    def filters_applied?
+      @filters_applied ||= begin
+        return true if allowed_creative_ids.present?
+
+        filtered = raw_params.except(*FILTER_IGNORED_KEYS)
+        filtered.present?
+      end
+    end
+
+    def template_payload_for(creative)
+      description_html = view_context.embed_youtube_iframe(creative.effective_description(raw_params["tags"]&.first))
+      progress_html = view_context.render_creative_progress(creative, select_mode: !!select_mode)
+
+      {
+        description_html: description_html,
+        progress_html: progress_html,
+        edit_icon_html: edit_icon_html,
+        edit_off_icon_html: edit_off_icon_html,
+        origin_link_html: origin_link_html_for(creative)
+      }
+    end
+
+    def inline_editor_payload_for(creative)
+      {
+        description_raw_html: creative.effective_description(nil, true),
+        progress: creative.progress,
+        origin_id: creative.origin_id
+      }
+    end
+
+    def children_container_payload(creative, filtered_children, child_level:, children_nodes:, expanded:, load_children_now:)
+      return nil unless filtered_children.any?
+
+      {
+        id: "creative-children-#{creative.id}",
+        expanded: expanded,
+        loaded: load_children_now,
+        load_url: view_context.collavre.children_creative_path(
+          creative,
+          level: child_level,
+          select_mode: select_mode ? 1 : 0
+        ),
+        level: child_level,
+        nodes: children_nodes
+      }
+    end
+
+    def edit_icon_html
+      @edit_icon_html ||= view_context.svg_tag("edit.svg", className: "icon-edit")
+    end
+
+    def edit_off_icon_html
+      @edit_off_icon_html ||= view_context.svg_tag("edit-off.svg", className: "icon-edit")
+    end
+
+    def origin_link_html_for(creative)
+      return unless creative.origin_id.present?
+
+      view_context.link_to(
+        view_context.collavre.creative_path(creative.origin),
+        class: "creative-origin-link creative-action-btn unstyled-link",
+        title: I18n.t("collavre.creatives.index.view_origin"),
+        aria: { label: I18n.t("collavre.creatives.index.view_origin") }
+      ) do
+        view_context.svg_tag("arrow-right.svg", class: "creative-origin-link-icon", width: 16, height: 16)
+      end
+    end
+  end
+end
+end

data/app/services/collavre/creatives/tree_formatter.rb

@@ -0,0 +1,36 @@
+module Collavre
+  module Creatives
+    class TreeFormatter
+      def format(creatives)
+        roots = Array(creatives)
+        lines = []
+
+        roots.each do |root|
+          format_node(root, 0, lines)
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def format_node(node, depth, lines)
+        indent = " " * (depth * 4)
+        desc = ActionController::Base.helpers.strip_tags(node.effective_description(nil, false))
+        progress = node.progress || 0.0
+
+        node_data = { id: node.id, progress: progress, desc: desc }
+        lines << "#{indent}- #{node_data.to_json}"
+
+        # We need to handle children. If the node is a new instance (in tests),
+        # children might depend on how it's set up.
+        # In real app, we use children association.
+        # To match the logic in views/controllers where we might want specific ordering:
+        # We'll validly assume `children` association is available.
+        node.children.each do |child|
+          format_node(child, depth + 1, lines)
+        end
+      end
+    end
+  end
+end

data/app/services/collavre/gemini_parent_recommender.rb

@@ -0,0 +1,77 @@
+module Collavre
+  class GeminiParentRecommender
+    def initialize(client: default_client)
+      @client = client
+    end
+
+    def recommend(creative)
+      user = creative.user
+
+      # 1. Gather all potential category candidates
+      # Candidates: All creatives user can write to + creative's current parent (even if not writable?)
+      # Original logic: Distinct creatives having children + parent.
+      # Note: Using `joins(:children)` filters only those that have children.
+
+      categories = Creative
+                     .joins(:children)
+                     .distinct
+                     .where(origin_id: nil)
+                     .select { |c| c.has_permission?(user, :write) }
+
+      parent = creative.parent
+      if parent&.has_permission?(user, :write)
+        categories << parent
+      end
+      categories = categories.uniq
+
+      # Rebuild tree in memory to avoid N+1 in TreeFormatter
+      children_map = categories.group_by(&:parent_id)
+      categories.each do |c|
+        # Manually set the children association target
+        c.association(:children).target = (children_map[c.id] || []).select { |child| child.has_permission?(user, :write) }
+      end
+      category_ids = categories.index_by(&:id)
+      top_level_categories = categories.reject { |c| category_ids.key?(c.parent_id) }
+
+      tree_text = Creatives::TreeFormatter.new.format(top_level_categories)
+
+      prompt = build_prompt(tree_text, ActionController::Base.helpers.strip_tags(creative.description).to_s)
+      Rails.logger.info("### prompt=#{prompt}")
+
+      response = @client.chat([ { role: :user, parts: [ { text: prompt } ] } ])
+      ids = parse_response(response)
+
+      # Reconstruct paths for result
+      ids.map do |id|
+         c = Creative.find_by(id: id)
+         next unless c
+         path = c.ancestors.reverse.map { |a| ActionController::Base.helpers.strip_tags(a.description) } + [ ActionController::Base.helpers.strip_tags(c.description) ]
+         { id: id, path: path.join(" > ") }
+      end.compact
+    end
+
+    private
+
+    def default_client
+      AiClient.new(
+        vendor: "google",
+        model: "gemini-2.5-flash",
+        system_prompt: nil
+      )
+    end
+
+    def build_prompt(tree_text, description)
+      "#{tree_text}\n\nGiven the above creative tree, which ids are the best parents for \"#{description}\"? " \
+        "Reply with up to 5 ids separated by commas in descending order of relevance."
+    end
+
+    def parse_response(content)
+      return [] if content.blank?
+
+      content.to_s.split(/[\s,]+/)
+             .filter_map { |value| Integer(value, exception: false) }
+             .reject(&:zero?)
+             .first(5)
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Collavre
+  module Github
+    class Client
+      def initialize(account)
+        @client = Octokit::Client.new(access_token: account.token)
+        @client.auto_paginate = true
+      end
+
+      def organizations
+        client.organizations
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub organizations fetch failed: #{e.message}")
+        []
+      end
+
+      def repositories_for_authenticated_user
+        client.repos(nil, type: "all")
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub user repos fetch failed: #{e.message}")
+        []
+      end
+
+      def repositories_for_organization(org)
+        client.org_repos(org, type: "all")
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub org repos fetch failed: #{e.message}")
+        []
+      end
+
+      def pull_request_details(repo_full_name, number)
+        client.pull_request(repo_full_name, number)
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub PR fetch failed: #{e.message}")
+        nil
+      end
+
+      def pull_request_commit_messages(repo_full_name, number)
+        client
+          .pull_request_commits(repo_full_name, number)
+          .map { |commit| commit.commit&.message }
+          .compact
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub PR commits fetch failed: #{e.message}")
+        []
+      end
+
+      def pull_request_diff(repo_full_name, number)
+        files = client.pull_request_files(repo_full_name, number)
+        formatted = files.filter_map do |file|
+          next unless file.patch.present?
+
+          <<~DIFF.strip
+            diff --git a/#{file.filename} b/#{file.filename}
+            #{file.patch}
+          DIFF
+        end
+        formatted.join("\n\n").presence
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub PR files fetch failed: #{e.message}")
+        nil
+      end
+
+      def repository_hooks(repo_full_name)
+        client.hooks(repo_full_name)
+      rescue Octokit::Error, Faraday::Error => e
+        Rails.logger.warn("GitHub hooks fetch failed for #{repo_full_name}: #{e.message}")
+        []
+      end
+
+      def create_repository_webhook(repo_full_name, url:, secret:, events:, content_type: "json")
+        client.create_hook(
+          repo_full_name,
+          "web",
+          {
+            url: url,
+            content_type: content_type,
+            secret: secret
+          },
+          {
+            events: events,
+            active: true
+          }
+        )
+      end
+
+      def update_repository_webhook(repo_full_name, hook_id, url:, secret:, events:, content_type: "json")
+        client.edit_hook(
+          repo_full_name,
+          hook_id,
+          "web",
+          {
+            url: url,
+            content_type: content_type,
+            secret: secret
+          },
+          {
+            events: events,
+            active: true
+          }
+        )
+      end
+
+      def delete_repository_webhook(repo_full_name, hook_id)
+        client.remove_hook(repo_full_name, hook_id)
+      end
+
+      private
+
+      attr_reader :client
+    end
+  end
+end