feat: implement meta intelligence

Author: Bulletdev

app/jobs/sync_match_job.rb

@@ -57,6 +57,8 @@ def perform(match_id, organization_id, region = 'BR')
       create_player_match_stats(match, match_data[:participants], organization)
 
       Rails.logger.info("Successfully synced match #{match_id}")
+
+      MetaIntelligence::Jobs::UpdateMetaStatsJob.perform_later(organization_id)
     end
   rescue RiotApiService::NotFoundError => e
     Rails.logger.error("Match not found in Riot API: #{match_id} - #{e.message}")

app/models/organization.rb

@@ -48,7 +48,8 @@ class Organization < ApplicationRecord
   # New tier-based associations
   has_many :scrims, dependent: :destroy
   has_many :competitive_matches, dependent: :destroy
-  has_many :messages, dependent: :destroy
+  has_many :messages,     dependent: :destroy
+  has_many :saved_builds, dependent: :destroy
 
   # Validations
   validates :name, presence: true, length: { maximum: 255 }

app/models/saved_build.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Stores build configurations for champions, either created manually by coaches
+# or automatically aggregated from match history by BuildAggregatorService.
+#
+# Multi-tenant: always scoped by organization_id.
+# Performance metrics are calculated asynchronously by UpdateMetaStatsJob.
+#
+# @example Find best ADC builds for current patch
+#   org.saved_builds.by_role('adc').by_patch('14.24').ranked_by_win_rate
+class SavedBuild < ApplicationRecord
+  belongs_to :organization
+  belongs_to :created_by, class_name: 'User', optional: true
+
+  DATA_SOURCES = %w[manual aggregated].freeze
+  ROLES        = %w[top jungle mid adc support].freeze
+
+  validates :champion,    presence: true, length: { maximum: 100 }
+  validates :role,        inclusion: { in: ROLES }, allow_blank: true
+  validates :data_source, inclusion: { in: DATA_SOURCES }
+  validates :games_played, numericality: { greater_than_or_equal_to: 0 }
+  validates :win_rate,
+            numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 },
+            allow_nil: true
+
+  # --- Scopes ---
+
+  scope :by_champion, lambda { |champion|
+    where(champion: champion)
+  }
+
+  scope :by_role, lambda { |role|
+    where(role: role)
+  }
+
+  scope :by_patch, lambda { |patch|
+    where(patch_version: patch)
+  }
+
+  scope :aggregated, -> { where(data_source: 'aggregated') }
+  scope :manual,     -> { where(data_source: 'manual') }
+  scope :public_builds, -> { where(is_public: true) }
+
+  scope :ranked_by_win_rate, lambda {
+    order(win_rate: :desc, games_played: :desc)
+  }
+
+  scope :with_sufficient_sample, lambda {
+    where('games_played >= ?', MetaIntelligence::Services::BuildAggregatorService::MINIMUM_SAMPLE_SIZE)
+  }
+
+  # --- Predicates ---
+
+  # @return [Boolean] true if this build was auto-generated from match data
+  def aggregated?
+    data_source == 'aggregated'
+  end
+
+  # @return [Boolean] true if this build was manually created by a coach
+  def manual?
+    data_source == 'manual'
+  end
+
+  # @return [String] win rate formatted for display (e.g. "62.5%")
+  def win_rate_display
+    "#{win_rate.to_f.round(1)}%"
+  end
+
+end

app/modules/competitive/controllers/pro_matches_controller.rb

@@ -223,6 +223,89 @@ def sync_from_leaguepedia
         }, status: :service_unavailable
       end
 
+      # GET /api/v1/competitive/pro-matches/diagnose-missing
+      # Cross-reference Leaguepedia Cargo API with our DB to find missing games.
+      # Bypasses the ProStaff Scraper — queries Leaguepedia directly.
+      #
+      # @param overview_page [String] required — Leaguepedia OverviewPage
+      # @param our_team      [String] required — team name as in Leaguepedia
+      def diagnose_missing
+        overview_page = params.require(:overview_page)
+        our_team      = params[:our_team].presence
+        raise ActionController::ParameterMissing.new(:our_team) if our_team.blank?
+
+        service = ::Competitive::Services::LeaguepediaRecoveryService.new(current_organization)
+        games   = service.diagnose_missing(overview_page: overview_page, our_team: our_team)
+
+        missing = games.reject { |g| g[:present_in_db] }
+        present = games.select { |g| g[:present_in_db] }
+
+        render json: {
+          message: "Diagnosis complete for #{our_team}",
+          data: {
+            overview_page: overview_page,
+            our_team: our_team,
+            total_in_leaguepedia: games.size,
+            present_in_db: present.size,
+            missing_count: missing.size,
+            missing_games: missing,
+            present_games: present
+          }
+        }
+      rescue ActionController::ParameterMissing => e
+        render json: { error: { code: 'MISSING_PARAM', message: e.message } },
+               status: :unprocessable_entity
+      rescue StandardError => e
+        Rails.logger.error "[ProMatches#diagnose_missing] #{e.message}"
+        render json: { error: { code: 'LEAGUEPEDIA_ERROR', message: e.message } },
+               status: :service_unavailable
+      end
+
+      # POST /api/v1/competitive/pro-matches/recover-missing
+      # Recover missing games by querying Leaguepedia Cargo API directly.
+      # Bypasses the ProStaff Scraper — no SCRAPER_API_KEY required.
+      #
+      # Flow:
+      #   1. Fetch all ScoreboardGames for the overview_page from Leaguepedia
+      #   2. Filter to games involving our_team
+      #   3. Skip games already present in the DB (by external_match_id)
+      #   4. For each missing game, fetch ScoreboardPlayers and import
+      #
+      # @param overview_page [String] required — Leaguepedia OverviewPage
+      # @param our_team      [String] required — team name as in Leaguepedia
+      # @param stage         [String] optional — filter to a specific stage
+      def recover_missing
+        overview_page = params.require(:overview_page)
+        our_team      = params[:our_team].presence
+        raise ActionController::ParameterMissing.new(:our_team) if our_team.blank?
+
+        stage = params[:stage].presence
+
+        service = ::Competitive::Services::LeaguepediaRecoveryService.new(current_organization)
+        result  = service.recover_missing(
+          overview_page: overview_page,
+          our_team: our_team,
+          stage: stage
+        )
+
+        render json: {
+          message: "Recovery complete for #{our_team} in #{overview_page}",
+          data: {
+            overview_page: overview_page,
+            our_team: our_team,
+            stage: stage,
+            stats: result
+          }
+        }, status: :ok
+      rescue ActionController::ParameterMissing => e
+        render json: { error: { code: 'MISSING_PARAM', message: e.message } },
+               status: :unprocessable_entity
+      rescue StandardError => e
+        Rails.logger.error "[ProMatches#recover_missing] #{e.message}"
+        render json: { error: { code: 'LEAGUEPEDIA_ERROR', message: e.message } },
+               status: :service_unavailable
+      end
+
       # POST /api/v1/competitive/pro-matches/import
       # Import a match from PandaScore to our database
       def import