collavre 0.5.0 → 0.7.0

data/app/services/collavre/ai_agent/agent_lifecycle_manager.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Manages agent lifecycle during task execution:
+    # - Status broadcasting (thinking, streaming, idle)
+    # - Cancellation checking
+    # - Heartbeat management
+    class AgentLifecycleManager
+      # Minimum interval (in seconds) between cancellation checks to avoid excessive DB queries
+      CANCEL_CHECK_INTERVAL = 1.0
+      # Interval (in seconds) between agent_status heartbeats during streaming
+      AGENT_STATUS_HEARTBEAT_INTERVAL = 3.0
+
+      def initialize(task:, agent:, creative:)
+        @task = task
+        @agent = agent
+        @creative = creative
+        @last_cancel_check_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @last_heartbeat_at = @last_cancel_check_at
+      end
+
+      # Broadcast agent status change
+      def broadcast_status(status, content: nil)
+        return unless @creative
+
+        CommentsPresenceChannel.broadcast_agent_status(
+          @creative.effective_origin.id,
+          status: status,
+          agent_id: @agent.id,
+          agent_name: @agent.display_name,
+          task_id: @task.id,
+          content: content,
+          source_creative_id: @creative.id
+        )
+      end
+
+      # Check if task was cancelled, raise Collavre::CancelledError if so
+      def check_cancelled!
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        return if (now - @last_cancel_check_at) < CANCEL_CHECK_INTERVAL
+
+        @last_cancel_check_at = now
+        raise Collavre::CancelledError if @task.reload.status == "cancelled"
+      end
+
+      # Send heartbeat if interval passed
+      def heartbeat_if_needed
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if (now - @last_heartbeat_at) >= AGENT_STATUS_HEARTBEAT_INTERVAL
+          broadcast_status("streaming")
+          @last_heartbeat_at = now
+        end
+      end
+
+      # Handle cancellation cleanup
+      def handle_cancelled(reply_comment:, response_content:)
+        if reply_comment
+          if response_content.present?
+            reply_comment.content_will_change!
+            reply_comment.update!(content: response_content)
+            reply_comment.broadcast_update_to(
+              [ reply_comment.creative, :comments ],
+              partial: "collavre/comments/comment",
+              locals: { comment: reply_comment, streaming: false }
+            )
+            log_action("reply_created", { comment_id: reply_comment.id, content: response_content, partial: true })
+          else
+            reply_comment.destroy!
+          end
+        end
+
+        broadcast_status("idle")
+        log_action("cancelled", { message: "Task cancelled by user" })
+      end
+
+      private
+
+      def log_action(type, payload, result = nil)
+        @task.task_actions.create!(
+          action_type: type,
+          payload: payload,
+          result: result,
+          status: "done"
+        )
+      end
+    end
+  end
+end

data/app/services/collavre/ai_agent/message_builder.rb

@@ -15,8 +15,11 @@ module Collavre
 
       def build
         messages = []
+        @injected_creative_ids = Set.new
 
         append_creative_context(messages)
+        append_context_creatives(messages)
+        append_referenced_creative_contexts(messages)
         append_chat_history(messages)
         append_trigger_message(messages)
 
@@ -32,16 +35,92 @@ module Collavre
         creative = Creative.find_by(id: creative_id)
         return unless creative
 
+        effective = creative.effective_origin(Set.new)
+        topic = current_topic
+        topic_info = topic ? "\nTopic: #{topic.name} (id: #{topic.id})" : ""
+
+        if effective.data&.dig("disabled_self_context") == true
+          # Self-context disabled: inject only the ancestry chain so the AI
+          # knows where in the hierarchy the conversation is happening
+          ancestry = build_ancestry_chain(creative)
+          @injected_creative_ids << creative.id
+          messages << { role: "user", parts: [ { text: "Current Creative (id: #{creative.id}):#{topic_info}\nPath: #{ancestry}" } ] }
+        else
+          # Full self-context: inject the creative subtree
+          children_level = @agent.creative_children_level
+          max_depth = 1 + children_level
+          markdown = ApplicationController.helpers.render_creative_tree_markdown(
+            [ creative ], 1, true, max_depth: max_depth
+          )
+
+          @injected_creative_ids << creative.id
+          messages << { role: "user", parts: [ { text: "Creative (id: #{creative.id}):#{topic_info}\n#{markdown}" } ] }
+        end
+      end
+
+      def build_ancestry_chain(creative)
+        creative.self_and_ancestors.reverse.map(&:creative_snippet).join(" > ")
+      end
+
+      def append_context_creatives(messages)
+        creative_id = @context.dig("creative", "id")
+        return unless creative_id
+
+        creative = Creative.find_by(id: creative_id)
+        return unless creative
+
+        effective_origin = creative.effective_origin(Set.new)
+        context_ids = effective_origin.effective_context_ids
+        disabled_ids = Array(effective_origin.data&.dig("disabled_context_ids"))
+        active_ids = context_ids - disabled_ids - [ creative_id, effective_origin.id ]
+        return if active_ids.empty?
+
         children_level = @agent.creative_children_level
         max_depth = 1 + children_level
-        markdown = ApplicationController.helpers.render_creative_tree_markdown(
-          [ creative ], 1, true, max_depth: max_depth
-        )
 
-        topic = current_topic
-        topic_info = topic ? "\nTopic: #{topic.name} (id: #{topic.id})" : ""
+        active_ids.each do |ctx_id|
+          next if @injected_creative_ids.include?(ctx_id)
+
+          ctx = Creative.find_by(id: ctx_id)
+          next unless ctx
+
+          @injected_creative_ids << ctx_id
+          markdown = ApplicationController.helpers.render_creative_tree_markdown(
+            [ ctx ], 1, true, max_depth: max_depth
+          )
+
+          messages << {
+            role: "user",
+            parts: [ { text: "Context Creative (id: #{ctx.id}):\n#{markdown}" } ]
+          }
+        end
+      end
+
+      def append_referenced_creative_contexts(messages)
+        content = @context.dig("comment", "content")
+        return unless content
 
-        messages << { role: "user", parts: [ { text: "Creative (id: #{creative.id}):#{topic_info}\n#{markdown}" } ] }
+        children_level = @agent.creative_children_level
+        max_depth = 1 + children_level
+
+        # Extract creative IDs from markdown links like [title](/creatives/123)
+        content.scan(%r{\[[^\]]*\]\(/creatives/(\d+)\)}).flatten.uniq.each do |id_str|
+          creative_id = id_str.to_i
+          next if @injected_creative_ids.include?(creative_id)
+
+          creative = Creative.find_by(id: creative_id)
+          next unless creative
+
+          @injected_creative_ids << creative_id
+          markdown = ApplicationController.helpers.render_creative_tree_markdown(
+            [ creative ], 1, true, max_depth: max_depth
+          )
+
+          messages << {
+            role: "user",
+            parts: [ { text: "Referenced Creative (id: #{creative.id}):\n#{markdown}" } ]
+          }
+        end
       end
 
       def append_chat_history(messages)

data/app/services/collavre/ai_agent/response_finalizer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Handles finalization of AI agent responses:
+    # - Review workflow processing
+    # - Comment creation/update
+    # - Activity log reassociation
+    class ResponseFinalizer
+      def initialize(task:, agent:, original_comment:, reply_comment:, response_content:)
+        @task = task
+        @agent = agent
+        @original_comment = original_comment
+        @reply_comment = reply_comment
+        @response_content = response_content
+      end
+
+      # Whether the last finalization was a review-flow update (no new comment created)
+      attr_reader :review_flow
+
+      # Finalize the response, handling review workflow if applicable
+      # Returns the finalized comment or nil
+      def finalize
+        @review_flow = false
+        # If no content, destroy placeholder and return
+        if @response_content.blank?
+          @reply_comment&.destroy!
+          return nil
+        end
+
+        review_handler = ReviewHandler.new(@original_comment, @agent)
+
+        if @reply_comment
+          finalize_reply_comment(review_handler)
+        elsif @original_comment
+          create_reply_comment
+        end
+      end
+
+      private
+
+      def finalize_reply_comment(review_handler)
+        if @original_comment&.review_message? && review_handler.handle(@response_content, task: @task)
+          # Review workflow: update quoted comment in place (no new comment created)
+          @review_flow = true
+          review_handler.add_completion_reaction
+          reassociate_activity_logs(@reply_comment, @original_comment.quoted_comment)
+          @reply_comment.destroy!
+          @original_comment.quoted_comment
+        else
+          # Normal comment workflow
+          update_reply_comment
+          reassociate_activity_logs(@original_comment, @reply_comment)
+          @reply_comment
+        end
+      end
+
+      def update_reply_comment
+        @reply_comment.content_will_change!
+        @reply_comment.update!(content: @response_content)
+        @reply_comment.broadcast_update_to(
+          [ @reply_comment.creative, :comments ],
+          partial: "collavre/comments/comment",
+          locals: { comment: @reply_comment, streaming: false }
+        )
+
+        log_action("reply_created", { comment_id: @reply_comment.id, content: @response_content })
+      end
+
+      def create_reply_comment
+        reply_comment = @original_comment.creative.comments.create!(
+          content: @response_content,
+          user: @agent,
+          topic_id: @original_comment.topic_id
+        )
+
+        log_action("reply_created", { comment_id: reply_comment.id, content: @response_content })
+        reassociate_activity_logs(@original_comment, reply_comment)
+        reply_comment
+      end
+
+      def reassociate_activity_logs(from_comment, to_comment)
+        ActivityLog.where(comment: from_comment, user: @agent)
+                   .update_all(comment_id: to_comment.id)
+      end
+
+      def log_action(type, payload, result = nil)
+        @task.task_actions.create!(
+          action_type: type,
+          payload: payload,
+          result: result,
+          status: "done"
+        )
+      end
+    end
+  end
+end

data/app/services/collavre/ai_agent/response_streamer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Collavre
+  module AiAgent
+    # Handles streaming response content from AI to comments.
+    # Manages throttling, broadcasting, and placeholder cleanup.
+    class ResponseStreamer
+      # Minimum interval (in seconds) between streaming updates to avoid excessive DB writes
+      STREAM_THROTTLE_INTERVAL = 0.1
+
+      def initialize(reply_comment:, creative:)
+        @reply_comment = reply_comment
+        @creative = creative
+        @content = ""
+        @last_broadcast_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      # Append delta content and broadcast if throttle interval passed
+      def append(delta)
+        @content += delta
+
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if @reply_comment && (now - @last_broadcast_at) >= STREAM_THROTTLE_INTERVAL
+          update_and_broadcast(streaming: true)
+          @last_broadcast_at = now
+        end
+      end
+
+      # Get accumulated content
+      def content
+        @content
+      end
+
+      # Finalize streaming by broadcasting final update
+      def finalize
+        update_and_broadcast(streaming: false) if @reply_comment && @content.present?
+      end
+
+      # Check if there's content accumulated
+      def content_present?
+        @content.present?
+      end
+
+      private
+
+      def update_and_broadcast(streaming:)
+        @reply_comment.update_column(:content, @content)
+        @reply_comment.broadcast_update_to(
+          [ @reply_comment.creative, :comments ],
+          partial: "collavre/comments/comment",
+          locals: { comment: @reply_comment, streaming: streaming }
+        )
+      end
+    end
+  end
+end

data/app/services/collavre/ai_agent/review_handler.rb

@@ -34,7 +34,24 @@ module Collavre
         return false unless eligible?
 
         quoted_comment = @original_comment.quoted_comment
-        quoted_comment.update!(content: response_content)
+
+        # Save old content as a version if this is the first review (no versions yet)
+        if quoted_comment.comment_versions.empty?
+          quoted_comment.comment_versions.create!(
+            content: quoted_comment.content,
+            version_number: quoted_comment.next_version_number
+          )
+        end
+
+        # Save new content as the latest version
+        new_version = quoted_comment.comment_versions.create!(
+          content: response_content,
+          version_number: quoted_comment.next_version_number,
+          review_comment: @original_comment
+        )
+
+        # Update content and point to the new version
+        quoted_comment.update!(content: response_content, selected_version_id: new_version.id)
 
         task.task_actions.create!(
           action_type: "review_updated",