collavre 0.1.1 → 0.2.0

data/app/services/collavre/ai_agent_service.rb

@@ -1,5 +1,10 @@
 module Collavre
   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
+
     def initialize(task)
       @task = task
       @agent = task.agent
@@ -18,7 +23,7 @@ module Collavre
         log_action("prompt_generated", { messages: messages })
 
         # Call AI Client
-        response_content = ""
+        @response_content = ""
 
         # Enrich context for rendering
         rendering_context = @context.dup
@@ -34,72 +39,125 @@ module Collavre
 
         # Create a placeholder comment to stream into
         target_comment_id = @context.dig("comment", "id")
-        reply_comment = nil
-
-        if target_comment_id
-          original_comment = Comment.find_by(id: target_comment_id)
-          if original_comment
-            reply_comment = original_comment.creative.comments.create!(
-              content: "...", # Placeholder
-              user: @agent,
-              topic_id: original_comment.topic_id
-            )
-          end
+        @original_comment = target_comment_id ? Comment.find_by(id: target_comment_id) : nil
+        @reply_comment = nil
+
+        if @original_comment
+          @reply_comment = @original_comment.creative.comments.create!(
+            content: Comment::STREAMING_PLACEHOLDER_CONTENT, # Placeholder — replaced during streaming
+            user: @agent,
+            topic_id: @original_comment.topic_id
+          )
         end
 
-        # we may pass event payload also to the AI client for more context if needed - TODO
+        @creative = @context.dig("creative", "id") ? Creative.find_by(id: @context["creative"]["id"]) : nil
+
+        # Broadcast "thinking" status via presence channel
+        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: @context.dig("creative", "id") ? Creative.find_by(id: @context["creative"]["id"]) : nil,
+            creative: @creative,
             user: @agent,
-            comment: reply_comment || (@context.dig("comment", "id") ? Comment.find_by(id: @context["comment"]["id"]) : nil)
+            task: @task,
+            comment: @reply_comment || @original_comment
           }
         )
 
+        last_broadcast_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @last_cancel_check_at = last_broadcast_at
+
         client.chat(messages, tools: @agent.tools || []) do |delta|
-          response_content += delta
-
-          # Stream updates to the comment
-          if reply_comment
-            # We use update_column to avoid triggering full model callbacks/validations on every chunk
-            # but we *do* want to broadcast the update.
-            # However, calling 'update' trigger callbacks which might be heavy.
-            # Let's try direct broadcast or a lighter update.
-            # For now, let's just update the content.
-            # To avoid being too chatty we could throttle, but let's try direct updates first.
-
-            reply_comment.update_column(:content, response_content)
-
-            # Manually trigger broadcast for the content update
-            # We use broadcast_update_to to immediately stream the update
-            reply_comment.broadcast_update_to([ reply_comment.creative, :comments ], partial: "collavre/comments/comment")
+          check_cancelled!
+          @response_content += delta
+
+          # Stream updates to placeholder comment (throttled)
+          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"
+            )
+            last_broadcast_at = now
           end
         end
 
         # Log completion
-        log_action("completion", { response: response_content })
+        log_action("completion", { response: @response_content })
 
         # Final save to ensure everything is consistent and trigger final callbacks
-        if reply_comment
-          if response_content.present?
-            reply_comment.update!(content: response_content)
-            log_action("reply_created", { comment_id: reply_comment.id, content: response_content })
+        if @reply_comment
+          if @response_content.present?
+            # Force dirty tracking since update_column bypassed it during streaming
+            @reply_comment.content_will_change!
+            @reply_comment.update!(content: @response_content)
+            log_action("reply_created", { comment_id: @reply_comment.id, content: @response_content })
+
+            # Re-associate activity logs from the trigger comment to the reply comment
+            reassociate_activity_logs(@original_comment, @reply_comment)
           else
-            reply_comment.destroy!
+            @reply_comment.destroy!
           end
-        elsif target_comment_id && response_content.present?
-          # Fallback if creation failed earlier or logic changed
-          reply_to_comment(target_comment_id, response_content)
+        elsif target_comment_id && @response_content.present?
+          reply_to_comment(target_comment_id, @response_content)
         end
+
+        # Broadcast "idle" status
+        broadcast_agent_status("idle")
       end
+    rescue ApprovalPendingError => e
+      handle_approval_pending(e)
+      raise # Re-raise to signal the job to handle status
+    rescue CancelledError
+      handle_cancelled
+      raise
     end
 
     private
 
+    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 CancelledError if @task.reload.status == "cancelled"
+    end
+
+    def handle_cancelled
+      # Save accumulated content to the placeholder comment before stopping
+      if @reply_comment
+        if @response_content.present?
+          @reply_comment.content_will_change!
+          @reply_comment.update!(content: @response_content)
+          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
+      end
+
+      broadcast_agent_status("idle")
+      log_action("cancelled", { message: "Task cancelled by user" })
+    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
+      )
+    end
+
     def log_action(type, payload, result = nil)
       @task.task_actions.create!(
         action_type: type,
@@ -110,17 +168,9 @@ module Collavre
     end
 
     def build_messages
-      # This logic mimics the old AiResponder but adapts to the new context structure
-      # We might need to fetch the creative and history based on context
-
       messages = []
 
-      # Add context-specific messages
-      # For comment_created, we want the creative context and chat history
-
       if @context["creative"]
-        # We might need to re-fetch creative to get the full markdown if it's not in context
-        # But for efficiency, let's assume we fetch it if ID is present
         creative_id = @context.dig("creative", "id")
         if creative_id
           creative = Creative.find_by(id: creative_id)
@@ -131,17 +181,9 @@ module Collavre
         end
       end
 
-      # Add chat history
       if @context.dig("creative", "id")
         creative_id = @context["creative"]["id"]
-        # Fetch comments for context, excluding private ones unless owned by the user
-        # We need to be careful about which comments to include.
-        # For now, let's include non-private comments.
-
-        # We need to know who the "user" is to determine roles.
-        # In the new system, the agent is @agent.
 
-        # We need to filter by topic_id to maintain conversation context
         trigger_comment_id = @context.dig("comment", "id")
         trigger_comment = Comment.find_by(id: trigger_comment_id)
         topic_id = trigger_comment&.topic_id
@@ -149,28 +191,26 @@ module Collavre
         Comment.where(creative_id: creative_id, private: false)
                .where(topic_id: topic_id)
                .order(created_at: :desc)
-               .limit(50) # Limit history to avoid context window issues
-               .reverse # Re-order to chronological for the AI
+               .limit(50)
+               .reverse
                .each do |c|
-          next if c.id == @context.dig("comment", "id") # Skip the current trigger comment if it's in the list (it shouldn't be usually if we query right, but good to be safe)
+          next if c.id == @context.dig("comment", "id")
 
           role = (c.user_id == @agent.id) ? "model" : "user"
           content = c.content
 
-          # Strip mentions of the agent from user messages to clean up context
           if role == "user"
-             if content.match?(/\A@#{Regexp.escape(@agent.name)}:/i)
-               content = content.sub(/\A@#{Regexp.escape(@agent.name)}:\s*/i, "")
-             elsif content.match?(/\A@#{Regexp.escape(@agent.name)}\s+/i)
-               content = content.sub(/\A@#{Regexp.escape(@agent.name)}\s+/i, "")
-             end
+            if content.match?(/\A@#{Regexp.escape(@agent.name)}:/i)
+              content = content.sub(/\A@#{Regexp.escape(@agent.name)}:\s*/i, "")
+            elsif content.match?(/\A@#{Regexp.escape(@agent.name)}\s+/i)
+              content = content.sub(/\A@#{Regexp.escape(@agent.name)}\s+/i, "")
+            end
           end
 
           messages << { role: role, parts: [ { text: content } ] }
         end
       end
 
-      # Add the trigger payload
       payload_text = @context.dig("comment", "content") || @context.to_json
       messages << { role: "user", parts: [ { text: payload_text } ] }
 
@@ -188,6 +228,74 @@ module Collavre
       )
 
       log_action("reply_created", { comment_id: reply.id, content: content })
+      reassociate_activity_logs(original_comment, reply)
+    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 handle_approval_pending(error)
+      # Clean up placeholder comment if exists
+      @reply_comment&.destroy! if @reply_comment&.content == Comment::STREAMING_PLACEHOLDER_CONTENT
+
+      broadcast_agent_status("idle")
+
+      @task.update!(
+        status: "pending_approval",
+        pending_tool_call: {
+          tool_name: error.tool_name,
+          tool_call_id: error.tool_call_id,
+          arguments: error.tool_arguments,
+          requested_at: Time.current.iso8601
+        }
+      )
+
+      log_action("pending_approval", error.to_h)
+      create_approval_comment(error)
+    end
+
+    def create_approval_comment(error)
+      return unless @creative
+
+      approver = @creative.user || User.find_by(id: @context.dig("comment", "user_id"))
+      return unless approver
+
+      action_payload = {
+        action: "execute_tool",
+        tool_name: error.tool_name,
+        arguments: error.tool_arguments,
+        resume: {
+          task_id: @task.id,
+          tool_call_id: error.tool_call_id
+        }
+      }
+
+      args_display = if error.tool_arguments.present?
+                       JSON.pretty_generate(error.tool_arguments)
+      else
+                       I18n.t("collavre.ai_agent.approval.no_arguments")
+      end
+
+      content = I18n.t(
+        "collavre.ai_agent.approval.message",
+        tool_name: error.tool_name,
+        arguments: args_display
+      )
+
+      original_comment = Comment.find_by(id: @context.dig("comment", "id"))
+      topic_id = original_comment&.topic_id
+
+      Comment.create!(
+        creative: @creative,
+        content: content,
+        user: @agent,
+        approver: approver,
+        action: JSON.pretty_generate(action_payload),
+        topic_id: topic_id,
+        private: false
+      )
     end
   end
 end

data/app/services/collavre/ai_client.rb

@@ -78,6 +78,10 @@ module Collavre
       end
 
       response_content.presence
+    rescue ApprovalPendingError
+      raise # Re-raise approval errors without catching them
+    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}"
@@ -110,8 +114,7 @@ module Collavre
              .chat(model: model).tap do |chat|
         chat.with_instructions(system_prompt) if system_prompt.present?
         chat.on_tool_call do |tool_call|
-          # You can do on_tool_call, on_tool_result hook by ruby llm provides
-          # Rails.logger.info("Tool call: #{JSON.pretty_generate(tool_call.to_h)}")
+          check_tool_approval!(tool_call)
         end
         if tools.any?
           # Resolve tool names to classes using the gem's helper
@@ -121,6 +124,32 @@ module Collavre
       end
     end
 
+    def check_tool_approval!(tool_call)
+      tool_name = tool_call.name
+      task = context&.dig(:task)
+
+      # Check if this tool requires approval
+      mcp_tool = McpTool.find_by(name: tool_name)
+      return unless mcp_tool&.requires_approval?
+
+      # Check if we already have approval for this specific call (resume scenario)
+      if task&.pending_tool_call.present?
+        pending = task.pending_tool_call
+        if pending["tool_name"] == tool_name && pending["approved"]
+          # Already approved, clear the pending state and proceed
+          task.update!(pending_tool_call: nil)
+          return
+        end
+      end
+
+      # Requires approval - raise error to halt execution
+      raise ApprovalPendingError.new(
+        "Tool '#{tool_name}' requires approval before execution",
+        tool_call: tool_call,
+        task: task
+      )
+    end
+
     def add_messages(conversation, contents)
       Array(contents).each do |message|
         next if message.nil?

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

@@ -73,7 +73,8 @@ module Collavre
         SUPPORTED_ACTIONS = {
           "create_creative" => :create_creative,
           "update_creative" => :update_creative,
-          "approve_tool" => :approve_tool
+          "approve_tool" => :approve_tool,
+          "execute_tool" => :execute_tool
         }.freeze
 
         CREATIVE_ATTRIBUTES = %w[description progress].freeze
@@ -159,6 +160,51 @@ module Collavre
           tool.approve!
         end
 
+        def execute_tool(payload)
+          tool_name = payload["tool_name"]
+          arguments = payload["arguments"] || {}
+          resume_info = payload["resume"] || {}
+          task_id = resume_info["task_id"]
+          tool_call_id = resume_info["tool_call_id"]
+
+          raise InvalidActionError, "Tool name is required" if tool_name.blank?
+
+          # Execute the tool via MetaToolService
+          result = begin
+            ::Tools::MetaToolService.new.call(
+              action: "call",
+              tool_name: tool_name,
+              arguments: arguments
+            )
+          rescue StandardError => e
+            Rails.logger.error("Tool execution failed: #{e.message}")
+            { error: e.message }
+          end
+
+          # If there's a task to resume, update it and re-queue the job
+          if task_id.present?
+            task = Task.find_by(id: task_id)
+            if task
+              # Mark the tool call as approved with its result
+              task.update!(
+                pending_tool_call: {
+                  tool_name: tool_name,
+                  tool_call_id: tool_call_id,
+                  arguments: arguments,
+                  approved: true,
+                  result: result,
+                  approved_at: Time.current.iso8601
+                }
+              )
+
+              # Resume the AI agent job
+              AiAgentJob.perform_later(task)
+            end
+          end
+
+          result
+        end
+
         def process_action(payload)
           unless payload.is_a?(Hash)
             raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_format")

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

@@ -30,15 +30,18 @@ module Collavre
       def parsed_args
         @parsed_args ||= begin
           args = command_body
-          args = args.sub(/\A(today)\b/i, Time.zone.today.to_s) if args.match?(/\Atoday\b/i)
-          match = args.match(/\A(?:(\d{4}-\d{2}-\d{2}))?(?:@(\d{2}:\d{2}))?(?:\s+(.*))?\z/)
-          return unless match
-          return unless match[1].present? || match[2].present?
+          return if args.blank?
+
+          date_token, time_token, memo = parse_command_parts(args)
+          return unless date_token || time_token
+
+          parsed_date = parse_date_token(date_token)
+          return if date_token.present? && parsed_date.blank?
 
           {
-            date: match[1],
-            time: match[2],
-            memo: match[3]
+            date: parsed_date&.to_s,
+            time: time_token,
+            memo: memo
           }
         end
       end
@@ -47,6 +50,79 @@ module Collavre
         comment.content.to_s.strip.sub(/\A\S+/, "").strip
       end
 
+      def parse_command_parts(args)
+        if args.start_with?("@")
+          match = args.match(/\A@(\d{2}:\d{2})(?:\s+(.*))?\z/)
+          return unless match
+
+          return [ nil, match[1], match[2] ]
+        end
+
+        # Use [^\s@]+ to stop before @ so "today@14:00" splits correctly
+        match = args.match(/\A([^\s@]+)?(?:@(\d{2}:\d{2}))?(?:\s+(.*))?\z/)
+        return unless match
+
+        [ match[1], match[2], match[3] ]
+      end
+
+      def parse_date_token(token)
+        return if token.blank?
+
+        today = Time.zone.today
+        token = token.strip
+
+        return today if token.match?(/\Atoday\z/i)
+        return today + 1.day if token.match?(/\Atomorrow\z/i)
+
+        interval_match = token.match(/\A\+(\d+)(days?|weeks?|months?|years?)\z/i)
+        if interval_match
+          amount = interval_match[1].to_i
+          unit = interval_match[2].downcase
+          return today + amount.days if unit.start_with?("day")
+          return today + amount.weeks if unit.start_with?("week")
+          return today.advance(months: amount) if unit.start_with?("month")
+          return today.advance(years: amount) if unit.start_with?("year")
+        end
+
+        weekday_match = token.match(/\A\+(\d+)?(mon|tue|wed|thu|fri|sat|sun|[월화수목금토일])\z/i)
+        if weekday_match
+          count = weekday_match[1].present? ? weekday_match[1].to_i : 1
+          return next_weekday(today, weekday_index(weekday_match[2]), count)
+        end
+
+        # YYYY-MM-DD
+        return Date.iso8601(token) if token.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+
+        # MM-DD (assume current year)
+        if token.match?(/\A\d{2}-\d{2}\z/)
+          return Date.parse("#{today.year}-#{token}")
+        end
+
+        nil
+      end
+
+      def weekday_index(token)
+        case token.to_s.downcase
+        when "mon", "월" then 1
+        when "tue", "화" then 2
+        when "wed", "수" then 3
+        when "thu", "목" then 4
+        when "fri", "금" then 5
+        when "sat", "토" then 6
+        when "sun", "일" then 0
+        end
+      end
+
+      def next_weekday(base_date, target_wday, count)
+        days_until = (target_wday - base_date.wday) % 7
+        days_until = 7 if days_until.zero?
+        base_date + days_until + (count - 1) * 7
+      end
+
+      def google_login?
+        user&.google_refresh_token.present?
+      end
+
       def create_event
         data = parsed_args
         return unless data
@@ -54,20 +130,46 @@ module Collavre
         timezone = Time.zone
         start_time, end_time = calculate_times(timezone, data[:date], data[:time])
         summary = build_summary(data[:memo])
+
+        # Always create local CalendarEvent first
+        calendar_event = CalendarEvent.create!(
+          user: user,
+          creative: creative,
+          summary: summary,
+          start_time: start_time,
+          end_time: end_time
+        )
+
+        # Sync to Google Calendar if connected
+        if google_login?
+          sync_to_google(calendar_event, timezone, data[:time].nil?)
+        else
+          I18n.t("collavre.comments.calendar_command.event_created_local")
+        end
+      end
+
+      def sync_to_google(calendar_event, timezone, all_day)
         calendar_id = comment.user&.calendar_id.presence || "primary"
 
-        event = GoogleCalendarService.new(user: user).create_event(
+        google_event = GoogleCalendarService.new(user: user).create_google_event(
           calendar_id: calendar_id,
-          start_time: start_time,
-          end_time: end_time,
-          summary: summary,
+          start_time: calendar_event.start_time,
+          end_time: calendar_event.end_time,
+          summary: calendar_event.summary,
           description: event_description,
           timezone: timezone.tzinfo.name,
-          all_day: data[:time].nil?,
-          creative: creative
+          all_day: all_day
+        )
+
+        calendar_event.update!(
+          google_event_id: google_event.id,
+          html_link: google_event.html_link
         )
 
-        I18n.t("collavre.comments.calendar_command.event_created", url: event.html_link)
+        I18n.t("collavre.comments.calendar_command.event_created", url: google_event.html_link)
+      rescue StandardError => e
+        Rails.logger.error("Google Calendar sync failed: #{e.message}")
+        I18n.t("collavre.comments.calendar_command.event_created_sync_failed")
       end
 
       def calculate_times(timezone, date_str, time_str)
@@ -82,10 +184,7 @@ module Collavre
       end
 
       def build_summary(memo)
-        return memo if memo.present?
-
-        base_summary = creative.effective_description(false, false)
-        base_summary
+        memo.presence || creative.effective_description(false, false)
       end
 
       def event_description