collavre 0.1.0

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

@@ -0,0 +1,262 @@
+module Collavre
+  require "json"
+
+  module Comments
+    class ActionExecutor
+      class ExecutionError < StandardError; end
+
+      def initialize(comment:, executor:)
+        @comment = comment
+        @executor = executor
+      end
+
+      def call
+        comment.with_lock do
+          prepare_for_execution!
+
+          execute_within_transaction!
+        end
+      rescue ExecutionError
+        raise
+      rescue StandardError, ScriptError => e
+        Rails.logger.error("Comment action execution failed: #{e.class} #{e.message}")
+        raise ExecutionError, I18n.t("collavre.comments.approve_execution_failed", message: e.message)
+      end
+
+      private
+
+      attr_reader :comment, :executor
+
+      def prepare_for_execution!
+        comment.reload
+
+        status = comment.approval_status(executor)
+        if status != :ok
+          error_key = case status
+          when :invalid_action_format then "collavre.comments.approve_invalid_format"
+          when :missing_action then "collavre.comments.approve_missing_action"
+          when :missing_approver then "collavre.comments.approve_missing_approver"
+          when :admin_required then "collavre.comments.approve_admin_required"
+          else "collavre.comments.approve_not_allowed"
+          end
+          raise ExecutionError, I18n.t(error_key)
+        end
+
+        if comment.action_executed_at.present?
+          raise ExecutionError, I18n.t("collavre.comments.approve_already_executed")
+        end
+      end
+
+      def execute_within_transaction!
+        ApplicationRecord.transaction do
+          execute_action!
+          mark_execution_completed!
+        end
+      end
+
+      def mark_execution_completed!
+        comment.action_executed_at = Time.current
+        comment.action_executed_by = executor
+        comment.approver = executor if comment.approver != executor
+        comment.save!
+      end
+
+      def execute_action!
+        ExecutionContext.new(comment).evaluate(comment.action)
+      rescue ExecutionContext::InvalidActionError => e
+        raise ExecutionError, e.message
+      end
+
+      class ExecutionContext
+        class InvalidActionError < StandardError; end
+
+        SUPPORTED_ACTIONS = {
+          "create_creative" => :create_creative,
+          "update_creative" => :update_creative,
+          "approve_tool" => :approve_tool
+        }.freeze
+
+        CREATIVE_ATTRIBUTES = %w[description progress].freeze
+
+        def initialize(comment)
+          @comment = comment
+        end
+
+        attr_reader :comment
+
+        def evaluate(code)
+          payload = parse_payload(code)
+
+          actions = Array(payload["actions"])
+          if actions.present?
+            Comment.transaction do
+              actions.each do |action_payload|
+                process_action(action_payload)
+              end
+            end
+          else
+            process_action(payload)
+          end
+        end
+
+        private
+
+        def parse_payload(code)
+          raise InvalidActionError, I18n.t("collavre.comments.approve_missing_action") if code.blank?
+
+          payload = JSON.parse(code)
+          unless payload.is_a?(Hash)
+            raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_format")
+          end
+
+          deep_stringify_keys(payload)
+        rescue JSON::ParserError
+          raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_format")
+        end
+
+        def deep_stringify_keys(value)
+          case value
+          when Hash
+            value.each_with_object({}) do |(key, inner_value), acc|
+              acc[key.to_s] = deep_stringify_keys(inner_value)
+            end
+          when Array
+            value.map { |item| deep_stringify_keys(item) }
+          else
+            value
+          end
+        end
+
+        def create_creative(payload)
+          attributes = extract_attributes(payload)
+          parent = parent_creative_for(payload)
+
+          new_creative = parent.children.build
+          new_creative.user = parent.user || comment.user || Current.user
+          assign_creative_attributes(new_creative, attributes)
+          new_creative.save!
+        rescue ActiveRecord::RecordInvalid => e
+          raise InvalidActionError, e.record.errors.full_messages.to_sentence
+        end
+
+        def update_creative(payload)
+          creative = find_target_creative(payload)
+          attributes = extract_attributes(payload)
+
+          assign_creative_attributes(creative, attributes)
+          creative.save!
+        rescue ActiveRecord::RecordInvalid => e
+          raise InvalidActionError, e.record.errors.full_messages.to_sentence
+        end
+
+        def approve_tool(payload)
+          tool_name = payload["tool_name"]
+          raise InvalidActionError, "Tool name is required" if tool_name.blank?
+
+          tool = McpTool.find_by(creative: comment.creative, name: tool_name)
+          raise InvalidActionError, "Tool '#{tool_name}' not found" unless tool
+
+          tool.approve!
+        end
+
+        def process_action(payload)
+          unless payload.is_a?(Hash)
+            raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_format")
+          end
+
+          action = payload["action"] || payload["type"]
+          raise InvalidActionError, I18n.t("collavre.comments.approve_missing_action") if action.blank?
+
+          handler = SUPPORTED_ACTIONS[action]
+          unless handler
+            raise InvalidActionError, I18n.t("collavre.comments.approve_unsupported_action", action: action)
+          end
+
+          send(handler, payload)
+        end
+
+        def extract_attributes(payload)
+          attributes = payload["attributes"]
+          unless attributes.is_a?(Hash)
+            raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_attributes")
+          end
+
+          sanitized = attributes.slice(*CREATIVE_ATTRIBUTES)
+          if sanitized.empty?
+            raise InvalidActionError, I18n.t("collavre.comments.approve_no_attributes")
+          end
+
+          deep_stringify_keys(validate_attribute_types(sanitized))
+        end
+
+        def validate_attribute_types(attributes)
+          attributes.each do |key, value|
+            case key.to_s
+            when "description"
+              unless value.is_a?(String)
+                raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_description")
+              end
+            when "progress"
+              unless value.is_a?(Numeric)
+                raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_progress")
+              end
+            end
+          end
+
+          attributes
+        end
+
+        def assign_creative_attributes(record, attributes)
+          assignable = attributes.except("description")
+          record.assign_attributes(assignable)
+          if attributes.key?("description")
+            record.description = attributes["description"]
+          end
+        end
+
+        def find_target_creative(payload)
+          creative_id = payload["creative_id"]
+          return comment.creative if creative_id.blank?
+
+          creative = find_creative_in_comment_tree(creative_id)
+          unless creative
+            raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_creative")
+          end
+
+          creative
+        end
+
+        def parent_creative_for(payload)
+          parent_id = payload["parent_id"]
+          return comment.creative if parent_id.blank?
+
+          creative = find_creative_in_comment_tree(parent_id)
+          unless creative
+            raise InvalidActionError, I18n.t("collavre.comments.approve_invalid_creative")
+          end
+
+          creative
+        end
+
+        def find_creative_in_comment_tree(creative_id)
+          id = creative_id.to_i
+          return if id <= 0
+
+          creative = Creative.find_by(id: id)
+          return unless creative
+
+          return creative if allowed_creative_ids.include?(creative.id)
+
+          origin = creative.effective_origin
+          return origin if origin && allowed_creative_ids.include?(origin.id)
+
+          nil
+        end
+
+        def allowed_creative_ids
+          @allowed_creative_ids ||= comment.creative.self_and_descendants.pluck(:id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Collavre
+  module Comments
+    class ActionValidator
+      class ValidationError < StandardError; end
+
+      def initialize(comment:)
+        @comment = comment
+      end
+
+      def validate!(code)
+        context = ActionExecutor::ExecutionContext.new(comment)
+        payload = context.send(:parse_payload, code)
+        validate_payload(context, payload)
+        payload
+      rescue ActionExecutor::ExecutionContext::InvalidActionError => e
+        raise ValidationError, e.message
+      end
+
+      private
+
+      attr_reader :comment
+
+      def validate_payload(context, payload)
+        actions = payload["actions"]
+        if actions.present?
+          Array(actions).each do |action_payload|
+            validate_single_action(context, action_payload)
+          end
+        else
+          validate_single_action(context, payload)
+        end
+      end
+
+      def validate_single_action(context, payload)
+        unless payload.is_a?(Hash)
+          raise ValidationError, I18n.t("collavre.comments.approve_invalid_format")
+        end
+
+        action = payload["action"] || payload["type"]
+        raise ValidationError, I18n.t("collavre.comments.approve_missing_action") if action.blank?
+
+        handler = ActionExecutor::ExecutionContext::SUPPORTED_ACTIONS[action]
+        unless handler
+          raise ValidationError, I18n.t("collavre.comments.approve_unsupported_action", action: action)
+        end
+
+        case handler
+        when :create_creative
+          context.send(:extract_attributes, payload)
+          context.send(:parent_creative_for, payload)
+        when :update_creative
+          context.send(:extract_attributes, payload)
+          context.send(:find_target_creative, payload)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+module Collavre
+  module Comments
+    class CalendarCommand
+      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 calendar_command?
+
+        create_event
+      rescue StandardError => e
+        Rails.logger.error("Calendar command failed: #{e.message}")
+        e.message
+      end
+
+      private
+
+      attr_reader :comment, :user, :creative, :url_helpers
+
+      COMMAND_PATTERN = /\A\/(?:calendar|cal)\b/i.freeze
+
+      def calendar_command?
+        comment.content.to_s.strip.match?(COMMAND_PATTERN)
+      end
+
+      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?
+
+          {
+            date: match[1],
+            time: match[2],
+            memo: match[3]
+          }
+        end
+      end
+
+      def command_body
+        comment.content.to_s.strip.sub(/\A\S+/, "").strip
+      end
+
+      def create_event
+        data = parsed_args
+        return unless data
+
+        timezone = Time.zone
+        start_time, end_time = calculate_times(timezone, data[:date], data[:time])
+        summary = build_summary(data[:memo])
+        calendar_id = comment.user&.calendar_id.presence || "primary"
+
+        event = GoogleCalendarService.new(user: user).create_event(
+          calendar_id: calendar_id,
+          start_time: start_time,
+          end_time: end_time,
+          summary: summary,
+          description: event_description,
+          timezone: timezone.tzinfo.name,
+          all_day: data[:time].nil?,
+          creative: creative
+        )
+
+        I18n.t("collavre.comments.calendar_command.event_created", url: event.html_link)
+      end
+
+      def calculate_times(timezone, date_str, time_str)
+        if time_str
+          date_for_time = date_str.presence || timezone.today.to_s
+          start_time = timezone.parse("#{date_for_time} #{time_str}")
+          [ start_time, start_time ]
+        else
+          start_time = Date.parse(date_str.presence || timezone.today.to_s)
+          [ start_time, start_time ]
+        end
+      end
+
+      def build_summary(memo)
+        return memo if memo.present?
+
+        base_summary = creative.effective_description(false, false)
+        base_summary
+      end
+
+      def event_description
+        defaults = Rails.application.config.action_mailer.default_url_options || {}
+        url_helpers.creative_url(creative, defaults.merge(comment_id: comment.id))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Collavre
+  module Comments
+    class CommandProcessor
+      def initialize(comment:, user:)
+        @comment = comment
+        @user = user
+      end
+
+      def call
+        command_handlers.each do |command|
+          result = command.call
+          return result if result.present?
+        end
+        nil
+      rescue StandardError => e
+        Rails.logger.error("Comment command processing failed: #{e.message}")
+        e.message
+      end
+
+      private
+
+      attr_reader :comment, :user
+
+      def command_handlers
+        static_commands + mcp_commands
+      end
+
+      def static_commands
+        [ Collavre::Comments::CalendarCommand.new(comment: comment, user: user) ]
+      end
+
+      def mcp_commands
+        Collavre::Comments::McpCommandBuilder.new(comment: comment, user: user).commands
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module Collavre
+  require "json"
+
+  module Comments
+    class McpCommand
+      def initialize(comment:, user:, tool:, meta_tool_service: default_meta_tool_service)
+        @comment = comment
+        @user = user
+        @tool = tool
+        @meta_tool_service = meta_tool_service
+      end
+
+      def call
+        return unless command_match?
+
+        arguments = parsed_arguments
+        return usage_message unless arguments
+
+        response = meta_tool_service.call(action: "run", tool_name: tool_name, arguments: arguments)
+        format_response(response)
+      rescue StandardError => e
+        Rails.logger.error("MCP command '#{tool_name}' failed: #{e.message}")
+        e.message
+      end
+
+      private
+
+      attr_reader :comment, :user, :tool, :meta_tool_service
+
+      def command_match?
+        comment.content.to_s.strip.match?(command_pattern)
+      end
+
+      def command_pattern
+        @command_pattern ||= /\A\/#{Regexp.escape(tool_name)}\b/i
+      end
+
+      def command_body
+        comment.content.to_s.strip.sub(command_pattern, "").strip
+      end
+
+      def parsed_arguments
+        body = command_body
+        return {} if body.blank?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        key_value_arguments(body)
+      end
+
+      def key_value_arguments(body)
+        args = body.split(/\s+/).each_with_object({}) do |pair, result|
+          key, value = pair.split("=", 2)
+          next if key.blank? || value.nil?
+
+          result[key] = cast_value(value)
+        end
+
+        return args if args.present?
+
+        nil
+      end
+
+      def cast_value(value)
+        case value
+        when /\A\d+\z/ then value.to_i
+        when /\A\d+\.\d+\z/ then value.to_f
+        when /\Atrue\z/i then true
+        when /\Afalse\z/i then false
+        else
+          value
+        end
+      end
+
+      def usage_message
+        params = Array(tool[:params]).map { |param| param[:name] }.join(" ").presence
+        usage = [ tool_name, params ].compact.join(" ")
+        "Usage: /#{usage}"
+      end
+
+      def format_response(response)
+        # TODO: i18n text
+        return "Error running /#{tool_name}: #{response[:error]}" if response[:error].present?
+
+        result = response[:result]
+        content = case result
+        when Hash, Array
+          JSON.pretty_generate(result)
+        else
+          result.to_s
+        end
+
+        <<~HTML
+        <details><summary>#{tool_name} response</summary>
+        <pre><code>#{content}</code></pre>
+        </details>
+        HTML
+      end
+
+      def tool_name
+        tool[:name]
+      end
+
+      def default_meta_tool_service
+        ::Tools::MetaToolService.new
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Collavre
+  module Comments
+    class McpCommandBuilder
+      def initialize(comment:, user:, logger: Rails.logger)
+        @comment = comment
+        @user = user
+        @logger = logger
+      end
+
+      def commands
+        return [] unless defined?(RailsMcpEngine)
+
+        RailsMcpEngine::Engine.build_tools!
+        tools = meta_tool_service.call(action: "list", tool_name: nil, query: nil, arguments: nil)
+        Array(tools[:tools]).map do |tool|
+          Collavre::Comments::McpCommand.new(comment: comment, user: user, tool: tool, meta_tool_service: meta_tool_service)
+        end
+      rescue StandardError => e
+        logger.error("MCP command registration failed: #{e.message}")
+        []
+      end
+
+      private
+
+      attr_reader :comment, :user, :logger
+
+      def meta_tool_service
+        @meta_tool_service ||= ::Tools::MetaToolService.new
+      end
+    end
+  end
+end