collavre 0.2.5 → 0.3.1

data/app/services/collavre/ai_agent_service.rb

@@ -32,11 +32,19 @@ module Collavre
           rendering_context["creative"] = creative.as_json if creative
         end
 
+        # Add agent collaboration context
+        agent_context = build_agent_context(creative)
+        rendering_context.merge!(agent_context)
+
         rendered_system_prompt = AiSystemPromptRenderer.new(
           template: @agent.system_prompt,
           context: rendering_context
         ).render
 
+        # Append collaboration guide to system prompt
+        collaboration_prompt = build_collaboration_prompt(creative)
+        rendered_system_prompt = "#{rendered_system_prompt}\n\n#{collaboration_prompt}" if collaboration_prompt.present?
+
         # Create a placeholder comment to stream into
         target_comment_id = @context.dig("comment", "id")
         @original_comment = target_comment_id ? Comment.find_by(id: target_comment_id) : nil
@@ -109,6 +117,8 @@ module Collavre
 
         # Broadcast "idle" status
         broadcast_agent_status("idle")
+
+        @response_content
       end
     rescue ApprovalPendingError => e
       handle_approval_pending(e)
@@ -154,7 +164,8 @@ module Collavre
         agent_id: @agent.id,
         agent_name: @agent.display_name,
         task_id: @task.id,
-        content: content
+        content: content,
+        source_creative_id: @creative.id
       )
     end
 
@@ -236,6 +247,26 @@ module Collavre
                  .update_all(comment_id: to_comment.id)
     end
 
+    def build_agent_context(creative)
+      return {} unless creative
+
+      Orchestration::AgentContextBuilder.new(
+        agent: @agent,
+        creative: creative,
+        sender: @context["sender"]
+      ).build
+    end
+
+    def build_collaboration_prompt(creative)
+      return nil unless creative
+
+      Orchestration::AgentContextBuilder.new(
+        agent: @agent,
+        creative: creative,
+        sender: @context["sender"]
+      ).to_collaboration_prompt
+    end
+
     def handle_approval_pending(error)
       # Clean up placeholder comment if exists
       @reply_comment&.destroy! if @reply_comment&.content == Comment::STREAMING_PLACEHOLDER_CONTENT

data/app/services/collavre/ai_client.rb

@@ -83,10 +83,11 @@ module Collavre
     rescue CancelledError
       raise # Re-raise cancellation errors without catching them
     rescue StandardError => e
-      error_message = e.message
-      Rails.logger.error "AI Client error: #{e.message}"
+      error_message = "[#{e.class.name}] #{e.message}"
+      Rails.logger.error "AI Client error: #{error_message}"
+      Rails.logger.error "Partial response length: #{response_content.length} chars" if response_content.present?
       Rails.logger.debug e.backtrace.join("\n")
-      yield "AI Error: #{e.message}" if block_given?
+      yield "\n\n⚠️ AI Error: #{error_message}" if block_given?
       nil
     ensure
       log_interaction(

data/app/services/collavre/comments/command_processor.rb

@@ -26,7 +26,10 @@ module Collavre
       end
 
       def static_commands
-        [ Collavre::Comments::CalendarCommand.new(comment: comment, user: user) ]
+        [
+          Collavre::Comments::CalendarCommand.new(comment: comment, user: user),
+          Collavre::Comments::TopicCommand.new(comment: comment, user: user)
+        ]
       end
 
       def mcp_commands

data/app/services/collavre/comments/topic_command.rb

@@ -0,0 +1,101 @@
+module Collavre
+  module Comments
+    class TopicCommand
+      def initialize(comment:, user:, url_helpers: Collavre::Engine.routes.url_helpers)
+        @comment = comment
+        @user = user
+        @creative = comment.creative.effective_origin
+        @url_helpers = url_helpers
+      end
+
+      def call
+        return unless topic_command?
+
+        create_topic
+      rescue StandardError => e
+        Rails.logger.error("Topic command failed: #{e.message}")
+        e.message
+      end
+
+      private
+
+      attr_reader :comment, :user, :creative, :url_helpers
+
+      # /topic "topic name" @agent_name
+      # /topic "topic name"
+      COMMAND_PATTERN = /\A\/topic\b/i.freeze
+
+      def topic_command?
+        comment.content.to_s.strip.match?(COMMAND_PATTERN)
+      end
+
+      def parsed_args
+        @parsed_args ||= begin
+          content = comment.content.to_s.strip
+
+          # Extract topic name in quotes
+          name_match = content.match(/[\u201c\u201d""]([^"\u201c\u201d""]+)[\u201c\u201d""]|"([^"]+)"/)
+          topic_name = name_match ? (name_match[1] || name_match[2]) : nil
+
+          return if topic_name.blank?
+
+          { name: topic_name }
+        end
+      end
+
+      def create_topic
+        data = parsed_args
+        return I18n.t("collavre.comments.topic_command.missing_name") if data.blank?
+
+        # Find primary agent from @mentions using the same parsing as chat
+        primary_agent = comment.mentioned_users.find(&:ai_user?)
+
+        # Find existing topic or create new one
+        existing_topic = Topic.find_by(creative: creative, name: data[:name])
+
+        if existing_topic
+          if primary_agent
+            set_primary_agent(existing_topic, primary_agent)
+            I18n.t("collavre.comments.topic_command.updated_agent",
+                   name: existing_topic.name,
+                   agent: primary_agent.name)
+          else
+            I18n.t("collavre.comments.topic_command.already_exists",
+                   name: existing_topic.name)
+          end
+        else
+          topic = Topic.create!(
+            creative: creative,
+            user: user,
+            name: data[:name]
+          )
+
+          if primary_agent
+            set_primary_agent(topic, primary_agent)
+            I18n.t("collavre.comments.topic_command.created_with_agent",
+                   name: topic.name,
+                   agent: primary_agent.name)
+          else
+            I18n.t("collavre.comments.topic_command.created", name: topic.name)
+          end
+        end
+      end
+
+      def set_primary_agent(topic, agent)
+        policy = OrchestratorPolicy.find_or_initialize_by(
+          policy_type: "arbitration",
+          scope_type: "Topic",
+          scope_id: topic.id
+        )
+        policy.update!(
+          config: {
+            "strategy" => "primary_first",
+            "primary_agent_id" => agent.id
+          },
+          priority: 10,
+          enabled: true
+        )
+      end
+    end
+  end
+end

data/app/services/collavre/orchestration/agent_context_builder.rb

@@ -0,0 +1,201 @@
+module Collavre
+  module Orchestration
+    # Builds context for AI agents including:
+    # - Agent identity
+    # - Available collaborators from Creative permissions
+    # - Organization hierarchy derived from permission levels
+    # - Sender context for A2A communication
+    #
+    # Permission → Role mapping:
+    # - admin:    escalation targets (supervisors)
+    # - write:    peers (collaborators)
+    # - feedback: reviewers
+    # - read:     information sources only
+    class AgentContextBuilder
+      PERMISSION_ROLES = {
+        "admin" => "escalation",    # Can escalate issues to
+        "write" => "collaborator",  # Can collaborate with
+        "feedback" => "reviewer",   # Can request reviews from
+        "read" => "reference"       # Can request information from
+      }.freeze
+
+      def initialize(agent:, creative:, sender: nil)
+        @agent = agent
+        @creative = creative
+        @sender = sender
+      end
+
+      def a2a_request?
+        @sender && @sender["is_ai"] == true
+      end
+
+      # Returns hash suitable for Liquid template rendering
+      def build
+        result = {
+          "agent" => build_agent_identity,
+          "collaborators" => build_collaborators,
+          "collaboration_guide" => build_collaboration_guide,
+          "is_a2a" => a2a_request?
+        }
+
+        result["sender"] = @sender if @sender
+        result
+      end
+
+      # Generates markdown-formatted collaboration section for system prompt
+      def to_collaboration_prompt
+        sections = []
+
+        # Add A2A request context if this is an agent-to-agent call
+        if a2a_request?
+          sections << I18n.t("collavre.ai_agent.a2a.request_header")
+          sections << ""
+          sections << I18n.t("collavre.ai_agent.a2a.request_description",
+                             sender_name: @sender["name"], sender_type: @sender["type"])
+          sections << I18n.t("collavre.ai_agent.a2a.focus_instruction")
+          sections << I18n.t("collavre.ai_agent.a2a.completion_instruction")
+          sections << I18n.t("collavre.ai_agent.a2a.followup_instruction")
+          sections << ""
+        end
+
+        collaborators = build_collaborators
+        return sections.join("\n") if collaborators.empty?
+
+        sections << I18n.t("collavre.ai_agent.collaboration.header")
+        sections << ""
+
+        # Group by role
+        by_role = collaborators.group_by { |c| c["role"] }
+
+        if by_role["escalation"]&.any?
+          sections << I18n.t("collavre.ai_agent.collaboration.escalation_header")
+          by_role["escalation"].each do |c|
+            sections << "- @#{c['name']}: #{c['description']}"
+          end
+          sections << ""
+        end
+
+        if by_role["collaborator"]&.any?
+          sections << I18n.t("collavre.ai_agent.collaboration.collaborator_header")
+          by_role["collaborator"].each do |c|
+            sections << "- @#{c['name']}: #{c['description']}"
+          end
+          sections << ""
+        end
+
+        if by_role["reviewer"]&.any?
+          sections << I18n.t("collavre.ai_agent.collaboration.reviewer_header")
+          by_role["reviewer"].each do |c|
+            sections << "- @#{c['name']}: #{c['description']}"
+          end
+          sections << ""
+        end
+
+        if by_role["reference"]&.any?
+          sections << I18n.t("collavre.ai_agent.collaboration.reference_header")
+          by_role["reference"].each do |c|
+            sections << "- @#{c['name']}: #{c['description']}"
+          end
+          sections << ""
+        end
+
+        sections << I18n.t("collavre.ai_agent.collaboration.rules_header")
+        sections << I18n.t("collavre.ai_agent.collaboration.mention_rule")
+        sections << I18n.t("collavre.ai_agent.collaboration.confidence_rule")
+        sections << I18n.t("collavre.ai_agent.collaboration.escalation_rule")
+        sections << I18n.t("collavre.ai_agent.collaboration.review_rule")
+        sections << ""
+
+        sections.join("\n")
+      end
+
+      private
+
+      def build_agent_identity
+        {
+          "id" => @agent.id,
+          "name" => @agent.name,
+          "display_name" => @agent.display_name,
+          "type" => extract_agent_type
+        }
+      end
+
+      def extract_agent_type
+        # Extract agent type from system_prompt or default
+        prompt = @agent.system_prompt.to_s.downcase
+        case prompt
+        when /developer|개발/ then "developer"
+        when /pm|project.?manager|프로젝트/ then "pm"
+        when /qa|test|quality|테스트|품질/ then "qa"
+        when /research|조사|연구/ then "researcher"
+        when /market|마케팅/ then "marketer"
+        when /plan|기획/ then "planner"
+        else "agent"
+        end
+      end
+
+      def build_collaborators
+        return [] unless @creative
+
+        # Get all AI agents with access to this creative tree
+        ai_agents_with_access.map do |user, permission|
+          next if user.id == @agent.id # Skip self
+
+          {
+            "id" => user.id,
+            "name" => user.name,
+            "display_name" => user.display_name,
+            "role" => PERMISSION_ROLES[permission] || "reference",
+            "permission" => permission,
+            "description" => extract_agent_description(user)
+          }
+        end.compact
+      end
+
+      def ai_agents_with_access
+        # Collect AI agents from creative and its ancestors
+        creatives_to_check = [ @creative ] + @creative.ancestors.to_a
+
+        agent_permissions = {}
+
+        creatives_to_check.each do |creative|
+          creative.creative_shares.includes(:user).each do |share|
+            user = share.user
+            next unless user&.ai_user?
+            next if share.permission == "no_access"
+
+            # Keep highest permission level
+            current = agent_permissions[user]
+            if current.nil? || permission_rank(share.permission) > permission_rank(current)
+              agent_permissions[user] = share.permission
+            end
+          end
+        end
+
+        agent_permissions.to_a
+      end
+
+      def permission_rank(permission)
+        CreativeShare.permissions[permission.to_s] || 0
+      end
+
+      def extract_agent_description(user)
+        prompt = user.system_prompt.to_s
+        # Extract first meaningful line or sentence
+        first_line = prompt.lines.find { |l| l.strip.present? && !l.start_with?("#") }
+        return "AI Agent" unless first_line
+
+        # Truncate to reasonable length
+        first_line.strip.truncate(100)
+      end
+
+      def build_collaboration_guide
+        {
+          "mention_format" => I18n.t("collavre.ai_agent.collaboration.mention_rule"),
+          "escalation_hint" => I18n.t("collavre.ai_agent.collaboration.escalation_rule"),
+          "review_hint" => I18n.t("collavre.ai_agent.collaboration.review_rule")
+        }
+      end
+    end
+  end
+end

data/app/services/collavre/orchestration/agent_orchestrator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Collavre
+  module Orchestration
+    # AgentOrchestrator is the single entry point for AI agent routing and scheduling.
+    # It coordinates the following components:
+    # - Matcher: determines which agents are qualified to respond
+    # - Arbiter: selects which agents will actually respond (floor control)
+    # - Scheduler: decides when to execute (resource management)
+    #
+    # Usage:
+    #   AgentOrchestrator.dispatch("comment_created", context)
+    #
+    class AgentOrchestrator
+      def self.dispatch(event_name, context)
+        new(event_name: event_name, context: context).dispatch
+      end
+
+      def self.dequeue_next_for_topic(topic_id)
+        task = Task.queued_for_topic(topic_id).first
+        return unless task
+
+        updated = Task.where(id: task.id, status: "queued").update_all(status: "pending")
+        if updated > 0
+          task.reload
+          refresh_deferred_context!(task)
+
+          if task.status == "cancelled"
+            # refresh_deferred_context! cancelled this task (no eligible comment),
+            # try the next queued task for this topic.
+            dequeue_next_for_topic(topic_id)
+          else
+            AiAgentJob.perform_later(task)
+          end
+        end
+      end
+
+      # Refresh trigger_event_payload so the deferred agent sees the latest
+      # conversation state instead of the stale snapshot from enqueue time.
+      # Skips AI agent's own comments to prevent self-response loops.
+      # Cancels the task if no eligible comment remains.
+      def self.refresh_deferred_context!(task)
+        context = task.trigger_event_payload
+        creative_id = context&.dig("creative", "id")
+        return unless creative_id && context&.key?("topic")
+
+        topic_id = context.dig("topic", "id")
+        scope = Comment
+          .where(creative_id: creative_id, topic_id: topic_id, private: false)
+          .where.not(user_id: task.agent_id)
+          .order(created_at: :desc)
+        latest_comment = scope.first
+
+        unless latest_comment
+          task.update!(status: "cancelled")
+          return
+        end
+
+        context["comment"] = {
+          "id" => latest_comment.id,
+          "content" => latest_comment.content,
+          "user_id" => latest_comment.user_id
+        }
+        context["chat"] = { "content" => latest_comment.content }
+        task.update!(trigger_event_payload: context)
+      end
+      private_class_method :refresh_deferred_context!
+
+      def initialize(event_name:, context:)
+        @event_name = event_name
+        # Build context ONCE here - no more duplicate builds
+        @context = SystemEvents::ContextBuilder.new(context).build
+        @context["event_name"] = event_name
+      end
+
+      def dispatch
+        # Step 1: Find qualified agents (Matcher)
+        candidates = matcher.match
+        return [] if candidates.empty?
+
+        # Step 2: Select responders (Arbiter) - with policy-based floor control
+        selected = arbiter.select(candidates)
+        return [] if selected.empty?
+
+        # Step 3: Schedule execution (Scheduler) - Phase 3
+        # For now, immediate execution
+        decisions = scheduler.schedule(selected)
+
+        # Step 4: Enqueue jobs
+        enqueue_jobs(decisions)
+      end
+
+      private
+
+      def policy_resolver
+        @policy_resolver ||= PolicyResolver.new(@context)
+      end
+
+      def matcher
+        @matcher ||= Matcher.new(@context)
+      end
+
+      def arbiter
+        @arbiter ||= Arbiter.new(@context, policy_resolver: policy_resolver)
+      end
+
+      def scheduler
+        @scheduler ||= Scheduler.new(@context, policy_resolver: policy_resolver)
+      end
+
+      def enqueue_jobs(decisions)
+        decisions.filter_map do |decision|
+          case decision[:timing]
+          when :immediate
+            AiAgentJob.perform_later(decision[:agent].id, @event_name, @context)
+            decision[:agent]
+          when :deferred
+            Task.create!(
+              name: "Response to #{@event_name}",
+              status: "queued",
+              trigger_event_name: @event_name,
+              trigger_event_payload: @context,
+              agent: decision[:agent],
+              topic_id: @context.dig("topic", "id")
+            )
+            decision[:agent]
+          when :delayed
+            AiAgentJob.set(wait: decision[:delay]).perform_later(
+              decision[:agent].id, @event_name, @context
+            )
+            decision[:agent]
+          when :rejected
+            Rails.logger.info(
+              "[Orchestrator] Agent #{decision[:agent].id} rejected: #{decision[:reason]}"
+            )
+            nil
+          end
+        end
+      end
+    end
+  end
+end