collavre 0.5.0 → 0.7.0

data/app/services/collavre/ai_agent_service.rb

@@ -1,11 +1,13 @@
 module Collavre
+  # Orchestrates AI agent execution for a task.
+  # Delegates specific concerns to specialized service objects:
+  # - AgentLifecycleManager: agent status, cancellation, heartbeats
+  # - ResponseStreamer: streaming content updates
+  # - ResponseFinalizer: comment finalization, review workflow
+  # - A2aDispatcher: agent-to-agent event dispatch
   class AiAgentService
-    # Minimum interval (in seconds) between streaming updates to avoid excessive DB writes
-    STREAM_THROTTLE_INTERVAL = 0.1
-    # 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
+    # Compatibility alias for constants moved to AgentLifecycleManager
+    CANCEL_CHECK_INTERVAL = AiAgent::AgentLifecycleManager::CANCEL_CHECK_INTERVAL
 
     def initialize(task)
       @task = task
@@ -17,94 +19,47 @@ module Collavre
       Current.set(user: @agent) do
         log_action("start", { message: "Starting agent execution" })
 
-        target_comment_id = @context.dig("comment", "id")
-        @original_comment = target_comment_id ? Comment.find_by(id: target_comment_id) : nil
+        # Build context and messages
+        @original_comment = find_original_comment
+        messages = build_messages
+        log_action("prompt_generated", { messages: messages })
 
-        messages = AiAgent::MessageBuilder.new(
-          agent: @agent, context: @context, original_comment: @original_comment
-        ).build
+        # Prepare rendering context and prompts
+        @creative = find_creative
+        rendering_context = prepare_rendering_context
+        system_prompt = render_system_prompt(rendering_context)
 
-        log_action("prompt_generated", { messages: messages })
+        # Create placeholder comment if needed
+        @reply_comment = create_reply_comment_if_needed
 
-        @response_content = ""
-
-        rendering_context = @context.dup
-        if @context.dig("creative", "id")
-          creative = Creative.find_by(id: @context["creative"]["id"])
-          rendering_context["creative"] = creative.as_json if creative
-        end
-
-        agent_context = build_agent_context(creative)
-        rendering_context.merge!(agent_context)
-
-        rendered_system_prompt = AiSystemPromptRenderer.new(
-          template: @agent.system_prompt,
-          context: rendering_context
-        ).render
-
-        collaboration_prompt = build_collaboration_prompt(creative)
-        rendered_system_prompt = "#{rendered_system_prompt}\n\n#{collaboration_prompt}" if collaboration_prompt.present?
-
-        @reply_comment = nil
-
-        if @original_comment
-          @reply_comment = @original_comment.creative.comments.create!(
-            content: Comment::STREAMING_PLACEHOLDER_CONTENT,
-            user: @agent,
-            topic_id: @original_comment.topic_id
-          )
-        end
-
-        @creative = @context.dig("creative", "id") ? Creative.find_by(id: @context["creative"]["id"]) : nil
-
-        broadcast_agent_status("thinking")
-
-        client = AiClient.new(
-          vendor: @agent.llm_vendor,
-          model: @agent.llm_model,
-          system_prompt: rendered_system_prompt,
-          llm_api_key: @agent.llm_api_key,
-          context: {
-            creative: @creative,
-            user: @agent,
-            task: @task,
-            comment: @reply_comment || @original_comment
-          }
+        # Initialize lifecycle manager
+        @lifecycle_manager = AiAgent::AgentLifecycleManager.new(
+          task: @task,
+          agent: @agent,
+          creative: @creative
         )
 
-        last_broadcast_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        last_heartbeat_at = last_broadcast_at
-        @last_cancel_check_at = last_broadcast_at
-
-        client.chat(messages, tools: @agent.tools || []) do |delta|
-          check_cancelled!
-          @response_content += delta
+        # Initialize response streamer
+        @streamer = AiAgent::ResponseStreamer.new(
+          reply_comment: @reply_comment,
+          creative: @creative
+        )
 
-          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          if @reply_comment && (now - last_broadcast_at) >= STREAM_THROTTLE_INTERVAL
-            @reply_comment.update_column(:content, @response_content)
-            @reply_comment.broadcast_update_to(
-              [ @reply_comment.creative, :comments ],
-              partial: "collavre/comments/comment",
-              locals: { comment: @reply_comment, streaming: true }
-            )
-            last_broadcast_at = now
-          end
+        @lifecycle_manager.broadcast_status("thinking")
 
-          # Periodic agent_status heartbeat so clients know we're still streaming
-          if (now - last_heartbeat_at) >= AGENT_STATUS_HEARTBEAT_INTERVAL
-            broadcast_agent_status("streaming")
-            last_heartbeat_at = now
-          end
-        end
+        # Execute AI chat with streaming
+        client = build_ai_client(system_prompt)
+        stream_response(client, messages)
 
-        log_action("completion", { response: @response_content })
+        log_action("completion", { response: @streamer.content })
 
-        finalize_response
+        # Finalize and dispatch (skip A2A for review-flow updates)
+        finalized_comment = finalize_response
+        dispatch_a2a(finalized_comment) unless @finalizer&.review_flow
 
-        broadcast_agent_status("idle")
+        @lifecycle_manager.broadcast_status("idle")
 
-        @response_content
+        @streamer.content
       end
     rescue ApprovalPendingError => e
       AiAgent::ApprovalHandler.new(
@@ -119,132 +74,124 @@ module Collavre
 
     private
 
-    def check_cancelled!
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      return if (now - @last_cancel_check_at) < CANCEL_CHECK_INTERVAL
+    def find_original_comment
+      target_comment_id = @context.dig("comment", "id")
+      target_comment_id ? Comment.find_by(id: target_comment_id) : nil
+    end
+
+    def build_messages
+      AiAgent::MessageBuilder.new(
+        agent: @agent,
+        context: @context,
+        original_comment: @original_comment
+      ).build
+    end
 
-      @last_cancel_check_at = now
-      raise CancelledError if @task.reload.status == "cancelled"
+    def find_creative
+      creative_id = @context.dig("creative", "id")
+      creative_id ? Creative.find_by(id: creative_id) : nil
     end
 
-    def handle_cancelled
-      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 })
-          reassociate_activity_logs(@original_comment, @reply_comment)
-        else
-          @reply_comment.destroy!
-        end
+    def prepare_rendering_context
+      rendering_context = @context.dup
+      if @creative
+        rendering_context["creative"] = @creative.as_json
       end
 
-      broadcast_agent_status("idle")
-      log_action("cancelled", { message: "Task cancelled by user" })
+      agent_context = build_agent_context(@creative)
+      rendering_context.merge!(agent_context)
+      rendering_context
     end
 
-    def finalize_response
-      review_handler = AiAgent::ReviewHandler.new(@original_comment, @agent)
-
-      if @reply_comment
-        if @response_content.present?
-          if @original_comment&.review_message? && review_handler.handle(@response_content, task: @task)
-            review_handler.add_completion_reaction
-            reassociate_activity_logs(@reply_comment, @original_comment.quoted_comment)
-            @reply_comment.destroy!
-          else
-            @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 })
-            reassociate_activity_logs(@original_comment, @reply_comment)
-            dispatch_a2a_if_needed
-          end
-        else
-          @reply_comment.destroy!
-        end
-      elsif @context.dig("comment", "id") && @response_content.present?
-        reply_to_comment(@context["comment"]["id"], @response_content)
+    def render_system_prompt(rendering_context)
+      rendered = AiSystemPromptRenderer.new(
+        template: @agent.system_prompt,
+        context: rendering_context
+      ).render
+
+      collaboration_prompt = build_collaboration_prompt(@creative)
+      if collaboration_prompt.present?
+        "#{rendered}\n\n#{collaboration_prompt}"
+      else
+        rendered
       end
     end
 
-    def broadcast_agent_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
+    def create_reply_comment_if_needed
+      return nil unless @original_comment
+
+      @original_comment.creative.comments.create!(
+        content: Comment::STREAMING_PLACEHOLDER_CONTENT,
+        user: @agent,
+        topic_id: @original_comment.topic_id
       )
     end
 
-    def log_action(type, payload, result = nil)
-      @task.task_actions.create!(
-        action_type: type,
-        payload: payload,
-        result: result,
-        status: "done"
+    def build_ai_client(system_prompt)
+      AiClient.new(
+        vendor: @agent.llm_vendor,
+        model: @agent.llm_model,
+        system_prompt: system_prompt,
+        llm_api_key: @agent.llm_api_key,
+        context: {
+          creative: @creative,
+          user: @agent,
+          task: @task,
+          comment: @reply_comment || @original_comment
+        }
       )
     end
 
-    def reply_to_comment(comment_id, content)
-      original_comment = Comment.find_by(id: comment_id)
-      return unless original_comment
+    def stream_response(client, messages)
+      client.chat(messages, tools: @agent.tools || []) do |delta|
+        @lifecycle_manager.check_cancelled!
+        @streamer.append(delta)
+        @lifecycle_manager.heartbeat_if_needed
+      end
+    end
 
-      @reply_comment = original_comment.creative.comments.create!(
-        content: content,
-        user: @agent,
-        topic_id: original_comment.topic_id
+    def finalize_response
+      @finalizer = AiAgent::ResponseFinalizer.new(
+        task: @task,
+        agent: @agent,
+        original_comment: @original_comment,
+        reply_comment: @reply_comment,
+        response_content: @streamer.content
       )
-
-      log_action("reply_created", { comment_id: @reply_comment.id, content: content })
-      reassociate_activity_logs(original_comment, @reply_comment)
-      dispatch_a2a_if_needed
+      @finalizer.finalize
     end
 
-    def dispatch_a2a_if_needed
-      return unless @reply_comment&.content.present?
+    def dispatch_a2a(finalized_comment)
+      return unless finalized_comment
 
-      # Find all mentioned AI agents anywhere in the response (not just at the start)
-      mentioned_agents = MentionParser.resolve_all_users(@reply_comment.content).select(&:ai_user?)
-      return if mentioned_agents.empty?
+      dispatcher = AiAgent::A2aDispatcher.new(
+        agent: @agent,
+        reply_comment: finalized_comment,
+        context: @context
+      )
+      dispatcher.dispatch
+    end
 
-      creative = @reply_comment.creative
+    def handle_cancelled
+      @lifecycle_manager.handle_cancelled(
+        reply_comment: @reply_comment,
+        response_content: @streamer.content
+      )
 
-      mentioned_agents.each do |mentioned_user|
-        if creative
-          context = { "creative" => { "id" => creative.id }, "topic" => { "id" => @reply_comment.topic_id } }
-          Orchestration::LoopBreaker.new(context).record_interaction(@agent.id, mentioned_user.id, creative.id)
-        end
+      # Reassociate activity logs if there was partial content
+      if @reply_comment && @streamer.content_present?
+        ActivityLog.where(comment: @original_comment, user: @agent)
+                   .update_all(comment_id: @reply_comment.id)
       end
-
-      # Dispatch event — downstream Matcher will route to the correct agent(s)
-      SystemEvents::Dispatcher.dispatch("comment_created", {
-        comment: { id: @reply_comment.id, content: @reply_comment.content, user_id: @reply_comment.user_id },
-        creative: { id: creative&.id, description: creative&.description },
-        topic: { id: @reply_comment.topic_id },
-        chat: { content: @reply_comment.content }
-      })
-    rescue StandardError => e
-      Rails.logger.error("[AiAgentService] A2A dispatch failed: #{e.message}")
     end
 
-    def reassociate_activity_logs(from_comment, to_comment)
-      ActivityLog.where(comment: from_comment, user: @agent)
-                 .update_all(comment_id: to_comment.id)
+    def log_action(type, payload, result = nil)
+      @task.task_actions.create!(
+        action_type: type,
+        payload: payload,
+        result: result,
+        status: "done"
+      )
     end
 
     def build_agent_context(creative)

data/app/services/collavre/ai_client.rb

@@ -8,12 +8,16 @@ module Collavre
       - Respond in the asker's language (prefer the latest user message). Keep code and error messages in their original form.
     PROMPT
 
+    attr_reader :last_input_tokens, :last_output_tokens
+
     def initialize(vendor:, model:, system_prompt:, llm_api_key: nil, context: {})
       @vendor = vendor
       @model = model
       @system_prompt = system_prompt
       @llm_api_key = llm_api_key
       @context = context
+      @last_input_tokens = 0
+      @last_output_tokens = 0
     end
 
     def chat(contents, tools: [], &block)
@@ -90,6 +94,8 @@ module Collavre
       yield "\n\n⚠️ AI Error: #{error_message}" if block_given?
       nil
     ensure
+      @last_input_tokens = input_tokens || 0
+      @last_output_tokens = output_tokens || 0
       log_interaction(
         messages: conversation.messages.to_a || Array(contents),
         tools: conversation.tools.to_a,

data/app/services/collavre/auto_theme_generator.rb

@@ -195,7 +195,7 @@ module Collavre
     def default_client
       AiClient.new(
         vendor: "google",
-        model: "gemini-2.5-flash",
+        model: "gemini-3-flash-preview",
         system_prompt: nil
       )
     end

data/app/services/collavre/command_menu_service.rb

@@ -26,6 +26,25 @@ module Collavre
           label: "/topic",
           description: I18n.t("collavre.comments.command_menu.topic_description"),
           args: I18n.t("collavre.comments.command_menu.topic_args")
+        },
+        {
+          name: "work",
+          label: "/work",
+          description: I18n.t("collavre.comments.command_menu.work_description"),
+          args: I18n.t("collavre.comments.command_menu.work_args")
+        },
+        {
+          name: "compress",
+          label: "/compress",
+          description: I18n.t("collavre.comments.command_menu.compress_description"),
+          args: I18n.t("collavre.comments.command_menu.compress_args")
+        },
+        {
+          name: "creative",
+          label: "/creative",
+          type: "popup",
+          popup_type: "creative_picker",
+          description: I18n.t("collavre.comments.command_menu.creative_description")
         }
       ]
     end

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

@@ -28,7 +28,9 @@ module Collavre
       def static_commands
         [
           Collavre::Comments::CalendarCommand.new(comment: comment, user: user),
-          Collavre::Comments::TopicCommand.new(comment: comment, user: user)
+          Collavre::Comments::TopicCommand.new(comment: comment, user: user),
+          Collavre::Comments::WorkCommand.new(comment: comment, user: user),
+          Collavre::Comments::CompressCommand.new(comment: comment, user: user)
         ]
       end
 

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

@@ -0,0 +1,75 @@
+module Collavre
+  module Comments
+    class CompressCommand
+      COMMAND_PATTERN = /\A\/compress\b/i.freeze
+
+      SYSTEM_PROMPT = <<~PROMPT.freeze
+        You are summarizing a conversation thread in a project management tool.
+        Preserve key decisions, action items, important context, and any conclusions.
+        Be concise but thorough. Respond in the same language as the conversation.
+        Use markdown formatting for readability.
+      PROMPT
+
+      def initialize(comment:, user:)
+        @comment = comment
+        @user = user
+        @creative = comment.creative
+      end
+
+      def call
+        return unless compress_command?
+
+        validate!
+        authorize!
+        enqueue_compress_job
+      rescue StandardError => e
+        Rails.logger.error("Compress command failed: #{e.message}")
+        e.message
+      end
+
+      private
+
+      attr_reader :comment, :user, :creative
+
+      def compress_command?
+        comment.content.to_s.strip.match?(COMMAND_PATTERN)
+      end
+
+      def extra_prompt
+        content = comment.content.to_s.strip
+        rest = content.sub(COMMAND_PATTERN, "").strip
+        rest.presence
+      end
+
+      def validate!
+        unless comment.topic_id.present?
+          raise I18n.t("collavre.comments.compress_command.topic_required")
+        end
+
+        # The /compress command comment may not be saved yet, so count existing non-compress comments
+        compress_pattern = /\A\/compress\b/i
+        existing_count = creative.comments.where(topic_id: comment.topic_id)
+          .reject { |c| c.content.to_s.strip.match?(compress_pattern) }.size
+        if existing_count < 2
+          raise I18n.t("collavre.comments.compress_command.nothing_to_compress")
+        end
+      end
+
+      def authorize!
+        unless creative.has_permission?(user, :write)
+          raise I18n.t("collavre.comments.compress_command.not_authorized")
+        end
+      end
+
+      def enqueue_compress_job
+        CompressJob.perform_later(
+          creative.id,
+          comment.topic_id,
+          user.id,
+          extra_prompt
+        )
+        I18n.t("collavre.comments.compress_command.started")
+      end
+    end
+  end
+end

data/app/services/collavre/comments/concerns/workflow_support.rb

@@ -0,0 +1,115 @@
+module Collavre
+  module Comments
+    module Concerns
+      module WorkflowSupport
+        extend ActiveSupport::Concern
+
+        private
+
+        # Filter creatives that already have active tasks or are completed
+        # Returns array of creative IDs to skip
+        def filter_active_or_completed(creative_ids)
+          return [] if creative_ids.empty?
+
+          # Skip creatives with active tasks (done/failed/cancelled allow re-work)
+          active = Task.where(creative_id: creative_ids)
+                       .where(status: %w[running queued pending pending_approval])
+                       .pluck(:creative_id)
+
+          # Skip creatives already completed (progress >= 1.0)
+          completed = Creative.where(id: creative_ids)
+                              .where("progress >= 1.0")
+                              .pluck(:id)
+
+          (active + completed).uniq
+        end
+
+        # DFS traversal of creative tree
+        def dfs_traverse(node, &block)
+          yield node
+          node.children.order(:sequence).each { |child| dfs_traverse(child, &block) }
+        end
+
+        # Find the original user who triggered the workflow
+        # Looks in: comment author → stored user_id → creative owner → agent
+        def find_original_user_from_task(task)
+          comment_id = task.trigger_event_payload&.dig("comment", "id")
+          comment = Comment.find_by(id: comment_id) if comment_id
+
+          # Try: comment author → stored user_id → creative owner → agent (last resort)
+          user = comment&.user
+          user ||= User.find_by(id: task.trigger_event_payload&.dig("comment", "user_id"))
+          user ||= task.creative&.user
+          user ||= task.agent
+
+          Rails.logger.warn("[WorkflowSupport] Using fallback user (#{user&.class}:#{user&.id}) for task ##{task.id}") unless comment&.user
+
+          user
+        end
+
+        # Post a notice comment to the original creative thread
+        def post_workflow_notice(task, content)
+          comment_id = task.trigger_event_payload&.dig("comment", "id")
+          unless comment_id
+            Rails.logger.warn("[WorkflowSupport] post_workflow_notice: no comment_id in trigger_event_payload: #{task.trigger_event_payload.inspect}")
+            return
+          end
+
+          original_comment = Comment.find_by(id: comment_id)
+          unless original_comment
+            Rails.logger.warn("[WorkflowSupport] post_workflow_notice: comment #{comment_id} not found")
+            return
+          end
+
+          Rails.logger.info("[WorkflowSupport] post_workflow_notice: posting to creative #{original_comment.creative_id}")
+          original_comment.creative.comments.create!(
+            content: content,
+            user: task.agent,
+            topic_id: original_comment.topic_id
+          )
+        end
+
+        # Resolve workflow context: if it's a creative ID, render that creative's markdown
+        def resolve_workflow_context_from_task(task, state)
+          # Use cached rendered context if available (avoids re-rendering in job context)
+          cached = state["rendered_workflow_context"]
+          return cached if cached.present?
+
+          context_text = task.workflow_context.to_s.strip
+          creative_id = context_text[/\A\d+\z/]
+
+          resolved = if creative_id
+                       context_creative = Creative.find_by(id: creative_id)
+                       if context_creative
+                         markdown = render_creative_markdown_for_task(task, context_creative)
+                         markdown.presence || context_text
+                       else
+                         context_text
+                       end
+          else
+                       context_text
+          end
+
+          # Cache for subsequent sub-tasks
+          state["rendered_workflow_context"] = resolved
+          task.update!(workflow_state: state)
+
+          resolved
+        end
+
+        # Render creative tree as markdown with agent's depth settings
+        def render_creative_markdown_for_task(task, creative)
+          max_depth = task.agent.creative_children_level + 1
+          result = ApplicationController.helpers.render_creative_tree_markdown(
+            [ creative ], 1, true, max_depth: max_depth
+          )
+          Rails.logger.info("[WorkflowSupport] render_creative_markdown: creative=#{creative.id} result_length=#{result&.length}")
+          result
+        rescue StandardError => e
+          Rails.logger.error("[WorkflowSupport] render_creative_markdown FAILED: creative=#{creative.id} error=#{e.class}: #{e.message}\n#{e.backtrace&.first(5)&.join("\n")}")
+          nil
+        end
+      end
+    end
+  end
+end