rubocop

Author: xfalcox

app/jobs/regular/generate_inferred_concepts.rb

@@ -51,17 +51,18 @@ def process_batch(item_ids, item_type, match_only)
 
     def process_item(item, item_type, match_only)
       # Use the Manager method that handles both identifying and creating concepts
+      manager = DiscourseAi::InferredConcepts::Manager.new
       if match_only
         if item_type == "topics"
-          DiscourseAi::InferredConcepts::Manager.match_topic_to_concepts(item)
+          manager.match_topic_to_concepts(item)
         else # posts
-          DiscourseAi::InferredConcepts::Manager.match_post_to_concepts(item)
+          manager.match_post_to_concepts(item)
         end
       else
         if item_type == "topics"
-          DiscourseAi::InferredConcepts::Manager.generate_concepts_from_topic(item)
+          manager.generate_concepts_from_topic(item)
         else # posts
-          DiscourseAi::InferredConcepts::Manager.generate_concepts_from_post(item)
+          manager.generate_concepts_from_post(item)
         end
       end
     end

app/jobs/scheduled/generate_concepts_from_popular_items.rb

@@ -17,8 +17,9 @@ def execute(_args)
 
     def process_popular_topics
       # Find candidate topics that are popular and don't have concepts yet
+      manager = DiscourseAi::InferredConcepts::Manager.new
       candidates =
-        DiscourseAi::InferredConcepts::Manager.find_candidate_topics(
+        manager.find_candidate_topics(
           limit: SiteSetting.inferred_concepts_daily_topics_limit || 20,
           min_posts: SiteSetting.inferred_concepts_min_posts || 5,
           min_likes: SiteSetting.inferred_concepts_min_likes || 10,
@@ -51,8 +52,9 @@ def process_popular_topics
 
     def process_popular_posts
       # Find candidate posts that are popular and don't have concepts yet
+      manager = DiscourseAi::InferredConcepts::Manager.new
       candidates =
-        DiscourseAi::InferredConcepts::Manager.find_candidate_posts(
+        manager.find_candidate_posts(
           limit: SiteSetting.inferred_concepts_daily_posts_limit || 30,
           min_likes: SiteSetting.inferred_concepts_post_min_likes || 5,
           exclude_first_posts: true,

lib/inferred_concepts/applier.rb

@@ -6,7 +6,7 @@ class Applier
       # Associates the provided concepts with a topic
       # topic: a Topic instance
       # concepts: an array of InferredConcept instances
-      def self.apply_to_topic(topic, concepts)
+      def apply_to_topic(topic, concepts)
         return if topic.blank? || concepts.blank?
 
         topic.inferred_concepts << concepts
@@ -15,15 +15,15 @@ def self.apply_to_topic(topic, concepts)
       # Associates the provided concepts with a post
       # post: a Post instance
       # concepts: an array of InferredConcept instances
-      def self.apply_to_post(post, concepts)
+      def apply_to_post(post, concepts)
         return if post.blank? || concepts.blank?
 
         post.inferred_concepts << concepts
       end
 
       # Extracts content from a topic for concept analysis
       # Returns a string with the topic title and first few posts
-      def self.topic_content_for_analysis(topic)
+      def topic_content_for_analysis(topic)
         return "" if topic.blank?
 
         # Combine title and first few posts for analysis
@@ -37,7 +37,7 @@ def self.topic_content_for_analysis(topic)
 
       # Extracts content from a post for concept analysis
       # Returns a string with the post content
-      def self.post_content_for_analysis(post)
+      def post_content_for_analysis(post)
         return "" if post.blank?
 
         # Get the topic title for context
@@ -50,14 +50,14 @@ def self.post_content_for_analysis(post)
       end
 
       # Match a topic with existing concepts
-      def self.match_existing_concepts(topic)
+      def match_existing_concepts(topic)
         return [] if topic.blank?
 
         # Get content to analyze
         content = topic_content_for_analysis(topic)
 
         # Get all existing concepts
-        existing_concepts = DiscourseAi::InferredConcepts::Manager.list_concepts
+        existing_concepts = DiscourseAi::InferredConcepts::Manager.new.list_concepts
         return [] if existing_concepts.empty?
 
         # Use the ConceptMatcher persona to match concepts
@@ -73,14 +73,14 @@ def self.match_existing_concepts(topic)
       end
 
       # Match a post with existing concepts
-      def self.match_existing_concepts_for_post(post)
+      def match_existing_concepts_for_post(post)
         return [] if post.blank?
 
         # Get content to analyze
         content = post_content_for_analysis(post)
 
         # Get all existing concepts
-        existing_concepts = DiscourseAi::InferredConcepts::Manager.list_concepts
+        existing_concepts = DiscourseAi::InferredConcepts::Manager.new.list_concepts
         return [] if existing_concepts.empty?
 
         # Use the ConceptMatcher persona to match concepts
@@ -96,7 +96,7 @@ def self.match_existing_concepts_for_post(post)
       end
 
       # Use ConceptMatcher persona to match content against provided concepts
-      def self.match_concepts_to_content(content, concept_list)
+      def match_concepts_to_content(content, concept_list)
         return [] if content.blank? || concept_list.blank?
 
         # Prepare user message with only the content

lib/inferred_concepts/finder.rb

@@ -5,7 +5,7 @@ module InferredConcepts
     class Finder
       # Identifies potential concepts from provided content
       # Returns an array of concept names (strings)
-      def self.identify_concepts(content)
+      def identify_concepts(content)
         return [] if content.blank?
 
         # Use the ConceptFinder persona to identify concepts
@@ -20,7 +20,7 @@ def self.identify_concepts(content)
           DiscourseAi::Personas::BotContext.new(
             messages: [{ type: :user, content: content }],
             user: Discourse.system_user,
-            inferred_concepts: DiscourseAi::InferredConcepts::Manager.list_concepts,
+            inferred_concepts: DiscourseAi::InferredConcepts::Manager.new.list_concepts,
           )
 
         bot = DiscourseAi::Personas::Bot.as(Discourse.system_user, persona: persona, model: llm)
@@ -35,7 +35,7 @@ def self.identify_concepts(content)
 
       # Creates or finds concepts in the database from provided names
       # Returns an array of InferredConcept instances
-      def self.create_or_find_concepts(concept_names)
+      def create_or_find_concepts(concept_names)
         return [] if concept_names.blank?
 
         concept_names.map { |name| InferredConcept.find_or_create_by(name: name) }
@@ -51,7 +51,7 @@ def self.create_or_find_concepts(concept_names)
       # @param category_ids [Array<Integer>] Only include topics from these categories (optional)
       # @param created_after [DateTime] Only include topics created after this time (optional)
       # @return [Array<Topic>] Array of Topic objects that are good candidates
-      def self.find_candidate_topics(
+      def find_candidate_topics(
         limit: 100,
         min_posts: 5,
         min_likes: 10,
@@ -104,7 +104,7 @@ def self.find_candidate_topics(
       # @param category_ids [Array<Integer>] Only include posts from topics in these categories
       # @param created_after [DateTime] Only include posts created after this time
       # @return [Array<Post>] Array of Post objects that are good candidates
-      def self.find_candidate_posts(
+      def find_candidate_posts(
         limit: 100,
         min_likes: 5,
         exclude_first_posts: true,
@@ -144,7 +144,7 @@ def self.find_candidate_posts(
       # Deduplicate and standardize a list of concepts
       # @param concept_names [Array<String>] List of concept names to deduplicate
       # @return [Hash] Hash with deduplicated concepts and mapping
-      def self.deduplicate_concepts(concept_names)
+      def deduplicate_concepts(concept_names)
         return { deduplicated_concepts: [], mapping: {} } if concept_names.blank?
 
         # Use the ConceptDeduplicator persona to deduplicate concepts

lib/inferred_concepts/manager.rb

@@ -6,7 +6,7 @@ class Manager
       # Get a list of existing concepts
       # @param limit [Integer, nil] Optional maximum number of concepts to return
       # @return [Array<InferredConcept>] Array of InferredConcept objects
-      def self.list_concepts(limit: nil)
+      def list_concepts(limit: nil)
         query = InferredConcept.all.order("name ASC")
 
         # Apply limit if provided
@@ -21,7 +21,7 @@ def self.list_concepts(limit: nil)
       # 2. Process each letter group separately through the deduplicator
       # 3. Do a final pass with all deduplicated concepts
       # @return [Hash] Statistics about the deduplication process
-      def self.deduplicate_concepts_by_letter(per_letter_batch: 50, full_pass_batch: 150)
+      def deduplicate_concepts_by_letter(per_letter_batch: 50, full_pass_batch: 150)
         # Get all concepts
         all_concepts = list_concepts
         return if all_concepts.empty?
@@ -42,14 +42,15 @@ def self.deduplicate_concepts_by_letter(per_letter_batch: 50, full_pass_batch: 1
 
         # Process each letter group
         letter_deduplicated_concepts = []
+        finder = DiscourseAi::InferredConcepts::Finder.new
 
         letter_groups.each do |letter, concepts|
           next if concepts.empty?
 
           batches = concepts.each_slice(per_letter_batch).to_a
 
           batches.each do |batch|
-            result = Finder.deduplicate_concepts(batch)
+            result = finder.deduplicate_concepts(batch)
             letter_deduplicated_concepts.concat(result)
           end
         end
@@ -60,7 +61,7 @@ def self.deduplicate_concepts_by_letter(per_letter_batch: 50, full_pass_batch: 1
 
           batches = letter_deduplicated_concepts.each_slice(full_pass_batch).to_a
           batches.each do |batch|
-            dedups = Finder.deduplicate_concepts(batch)
+            dedups = finder.deduplicate_concepts(batch)
             final_result.concat(dedups)
           end
 
@@ -76,32 +77,34 @@ def self.deduplicate_concepts_by_letter(per_letter_batch: 50, full_pass_batch: 1
       # Extract new concepts from arbitrary content
       # @param content [String] The content to analyze
       # @return [Array<String>] The identified concept names
-      def self.identify_concepts(content)
-        Finder.identify_concepts(content)
+      def identify_concepts(content)
+        DiscourseAi::InferredConcepts::Finder.new.identify_concepts(content)
       end
 
       # Identify and create concepts from content without applying them to any topic
       # @param content [String] The content to analyze
       # @return [Array<InferredConcept>] The created or found concepts
-      def self.generate_concepts_from_content(content)
+      def generate_concepts_from_content(content)
         return [] if content.blank?
 
         # Identify concepts
-        concept_names = Finder.identify_concepts(content)
+        finder = DiscourseAi::InferredConcepts::Finder.new
+        concept_names = finder.identify_concepts(content)
         return [] if concept_names.blank?
 
         # Create or find concepts in the database
-        Finder.create_or_find_concepts(concept_names)
+        finder.create_or_find_concepts(concept_names)
       end
 
       # Generate concepts from a topic's content without applying them to the topic
       # @param topic [Topic] A Topic instance
       # @return [Array<InferredConcept>] The created or found concepts
-      def self.generate_concepts_from_topic(topic)
+      def generate_concepts_from_topic(topic)
         return [] if topic.blank?
 
         # Get content to analyze
-        content = Applier.topic_content_for_analysis(topic)
+        applier = DiscourseAi::InferredConcepts::Applier.new
+        content = applier.topic_content_for_analysis(topic)
         return [] if content.blank?
 
         # Generate concepts from the content
@@ -111,11 +114,12 @@ def self.generate_concepts_from_topic(topic)
       # Generate concepts from a post's content without applying them to the post
       # @param post [Post] A Post instance
       # @return [Array<InferredConcept>] The created or found concepts
-      def self.generate_concepts_from_post(post)
+      def generate_concepts_from_post(post)
         return [] if post.blank?
 
         # Get content to analyze
-        content = Applier.post_content_for_analysis(post)
+        applier = DiscourseAi::InferredConcepts::Applier.new
+        content = applier.post_content_for_analysis(post)
         return [] if content.blank?
 
         # Generate concepts from the content
@@ -125,25 +129,25 @@ def self.generate_concepts_from_post(post)
       # Match a topic against existing concepts
       # @param topic [Topic] A Topic instance
       # @return [Array<InferredConcept>] The concepts that were applied
-      def self.match_topic_to_concepts(topic)
+      def match_topic_to_concepts(topic)
         return [] if topic.blank?
 
-        Applier.match_existing_concepts(topic)
+        DiscourseAi::InferredConcepts::Applier.new.match_existing_concepts(topic)
       end
 
       # Match a post against existing concepts
       # @param post [Post] A Post instance
       # @return [Array<InferredConcept>] The concepts that were applied
-      def self.match_post_to_concepts(post)
+      def match_post_to_concepts(post)
         return [] if post.blank?
 
-        Applier.match_existing_concepts_for_post(post)
+        DiscourseAi::InferredConcepts::Applier.new.match_existing_concepts_for_post(post)
       end
 
       # Find topics that have a specific concept
       # @param concept_name [String] The name of the concept to search for
       # @return [Array<Topic>] Topics that have the specified concept
-      def self.search_topics_by_concept(concept_name)
+      def search_topics_by_concept(concept_name)
         concept = ::InferredConcept.find_by(name: concept_name)
         return [] unless concept
         concept.topics
@@ -152,7 +156,7 @@ def self.search_topics_by_concept(concept_name)
       # Find posts that have a specific concept
       # @param concept_name [String] The name of the concept to search for
       # @return [Array<Post>] Posts that have the specified concept
-      def self.search_posts_by_concept(concept_name)
+      def search_posts_by_concept(concept_name)
         concept = ::InferredConcept.find_by(name: concept_name)
         return [] unless concept
         concept.posts
@@ -161,11 +165,11 @@ def self.search_posts_by_concept(concept_name)
       # Match arbitrary content against existing concepts
       # @param content [String] The content to analyze
       # @return [Array<String>] Names of matching concepts
-      def self.match_content_to_concepts(content)
+      def match_content_to_concepts(content)
         existing_concepts = InferredConcept.all.pluck(:name)
         return [] if existing_concepts.empty?
 
-        Applier.match_concepts_to_content(content, existing_concepts)
+        DiscourseAi::InferredConcepts::Applier.new.match_concepts_to_content(content, existing_concepts)
       end
 
       # Find candidate topics that are good for concept generation
@@ -179,15 +183,15 @@ def self.match_content_to_concepts(content)
       # @option opts [Array<Integer>] :category_ids (nil) Only include topics from these categories
       # @option opts [DateTime] :created_after (30.days.ago) Only include topics created after this time
       # @return [Array<Topic>] Array of Topic objects that are good candidates
-      def self.find_candidate_topics(opts = {})
-        Finder.find_candidate_topics(**opts)
+      def find_candidate_topics(opts = {})
+        DiscourseAi::InferredConcepts::Finder.new.find_candidate_topics(**opts)
       end
 
       # Find candidate posts that are good for concept generation
       # @param opts [Hash] Options to pass to the finder
       # @return [Array<Post>] Array of Post objects that are good candidates
-      def self.find_candidate_posts(opts = {})
-        Finder.find_candidate_posts(**opts)
+      def find_candidate_posts(opts = {})
+        DiscourseAi::InferredConcepts::Finder.new.find_candidate_posts(**opts)
       end
     end
   end

lib/personas/concept_finder.rb

@@ -8,7 +8,7 @@ def self.default_enabled
       end
 
       def system_prompt
-        existing_concepts = DiscourseAi::InferredConcepts::Manager.list_concepts(limit: 100)
+        existing_concepts = DiscourseAi::InferredConcepts::Manager.new.list_concepts(limit: 100)
         existing_concepts_text = ""
 
         existing_concepts_text = <<~CONCEPTS if existing_concepts.present?