collavre 0.1.0

data/app/services/collavre/mcp_service.rb

@@ -0,0 +1,217 @@
+module Collavre
+  require "digest"
+  require "set"
+
+  class McpService
+    # --- Registration Logic (from MetaToolService) ---
+
+    def self.register_tool_from_source(source_code)
+      # Extract tool name for logging context
+      tool_name_match = source_code.match(/tool_name\s+["'](.+?)["']/)
+      tool_name = tool_name_match ? tool_name_match[1] : "unknown_tool"
+
+      before_call = proc do |tool_instance, method_name, args|
+        # Store args for after_call access if needed, or just log start
+        # Using thread local to pass data to after_call if we want to correlate exact timing or args
+        Thread.current[:mcp_tool_args_stack] ||= []
+        Thread.current[:mcp_tool_args_stack].push(args)
+      end
+
+      after_call = proc do |tool_instance, method_name, result|
+        # Retrieve args
+        args = Thread.current[:mcp_tool_args_stack]&.pop || {}
+
+        # Create activity log
+        # We need a user to attribute this to.
+        # If executed in a background job (Task), Current.user is set.
+        # If executed via API, Current.user is set.
+        user = Current.user
+        creative = tool_instance&.try(:creative_context) rescue nil # Assuming some way to get context if needed, or nil
+
+        ActivityLog.create!(
+          activity: "tool_execution",
+          user: user,
+          creative: creative, # Optional: if we can link it back to a creative
+          log: {
+            tool_name: tool_name,
+            method: method_name,
+            args: args,
+            result: result
+          }
+        )
+      rescue => e
+        Rails.logger.error("Failed to log tool activity: #{e.message}")
+      end
+
+      result = ::Tools::MetaToolWriteService.new.register_tool_from_source(
+        source: source_code,
+        before_call: before_call,
+        after_call: after_call
+      )
+      puts("Registered tool: #{result}")
+
+      if result[:error]
+        error_msg = "Failed to register tool: #{result[:error]}"
+        Rails.logger.error(error_msg)
+        raise error_msg
+      end
+    rescue => e
+      Rails.logger.error("Failed to register tool from source: #{e.message}")
+      raise e
+    end
+
+    def self.filter_tools(tools, user)
+      return [] if tools.blank?
+
+      # Identify dynamic tools (user-defined) vs system tools.
+      # Tools can be objects (FastMcp::Tool) or Hashes (from MetaToolService)
+      registered_names = tools.map do |tool|
+        if tool.respond_to?(:tool_name)
+          tool.tool_name
+        elsif tool.is_a?(Hash)
+          tool[:name] || tool["name"]
+        end
+      end
+
+      # Check strict loading? No, simple where is fine.
+      dynamic_tools = McpTool.where(name: registered_names)
+      dynamic_tool_names = dynamic_tools.pluck(:name).to_set
+
+      # If user is present, find their owned tools
+      user_owned_tool_names = if user
+                                dynamic_tools
+                                  .joins(:creative)
+                                  .where(creatives: { user_id: user.id })
+                                  .pluck(:name)
+                                  .to_set
+      else
+                                Set.new
+      end
+
+      tools.select do |tool|
+        name = if tool.respond_to?(:tool_name)
+                 tool.tool_name
+        elsif tool.is_a?(Hash)
+                 tool[:name] || tool["name"]
+        else
+                 nil
+        end
+        if dynamic_tool_names.include?(name)
+          # It is a dynamic tool; user must own it.
+          user_owned_tool_names.include?(name)
+        else
+          # It is a system tool (not in McpTool database); allow it.
+          true
+        end
+      end
+    end
+
+    def self.load_active_tools
+      McpTool.active.find_each do |tool|
+        register_tool_from_source(tool.source_code)
+      end
+    end
+
+    def self.delete_tool(tool_name)
+      result = ::Tools::MetaToolWriteService.new.delete_tool(tool_name)
+
+      if result[:error]
+        Rails.logger.error("Failed to delete tool #{tool_name}: #{result[:error]}")
+      end
+    rescue => e
+      Rails.logger.error("Failed to delete tool #{tool_name}: #{e.message}")
+    end
+
+    # --- Creative Parsing Logic (from MetaToolWriteService) ---
+
+    def update_from_creative(input_creative)
+      creative = input_creative.effective_origin
+      return unless creative.description.present?
+
+      # Parse HTML to find code blocks
+      doc = Nokogiri::HTML.fragment(creative.description)
+
+      # Track found tools to identify removals
+      found_tool_names = []
+
+      # Find all code blocks.
+      # Lexical uses <pre class="lexical-code-block">.
+      # Standard markdown often uses <code>.
+      doc.css("pre.lexical-code-block, code").each do |node|
+        # Create a copy to manipulate
+        working_node = node.dup
+
+        # Replace <br> tags with newlines
+        working_node.search("br").each { |br| br.replace("\n") }
+
+        code = working_node.text
+
+        # Check if it looks like a tool definition
+        if code.include?("extend ToolMeta")
+          tool_name = process_tool_definition(creative, code)
+          found_tool_names << tool_name if tool_name
+        end
+      end
+
+      # Remove tools that are no longer in the description
+      # Ensure we look at the effective origin's tools
+      creative.mcp_tools.where.not(name: found_tool_names).destroy_all
+    end
+
+    private
+
+    def process_tool_definition(input_creative, code)
+      creative = input_creative.effective_origin
+      # Extract tool name using regex
+      tool_name_match = code.match(/tool_name\s+["'](.+?)["']/)
+      return unless tool_name_match
+
+      tool_name = tool_name_match[1]
+
+      mcp_tool = McpTool.find_or_initialize_by(creative: creative, name: tool_name)
+
+      # Calculate checksum to detect changes
+      new_checksum = Digest::SHA256.hexdigest(code)
+
+      if mcp_tool.new_record? || mcp_tool.checksum != new_checksum
+        # Unregister old tool if it exists (source changed)
+        if !mcp_tool.new_record?
+          McpService.delete_tool(tool_name)
+        end
+
+        mcp_tool.source_code = code
+        mcp_tool.checksum = new_checksum
+        mcp_tool.approved_at = nil # Reset approval status on change
+
+        # Extract description
+        desc_match = code.match(/tool_description\s+["'](.+?)["']/)
+        mcp_tool.description = desc_match[1] if desc_match
+
+        if mcp_tool.save
+          notify_approval_needed(creative, mcp_tool)
+        end
+      end
+
+      tool_name
+    end
+
+    def notify_approval_needed(creative, tool)
+      message = I18n.t("collavre.inbox.tool_approval_needed", tool_name: tool.name)
+
+      # Create a comment with action payload for approval
+      action_payload = {
+        action: "approve_tool",
+        tool_name: tool.name
+      }
+
+      Comment.create(
+        creative: creative,
+        content: message,
+        user: nil, # System message
+        approver: creative.user, # The creative owner should approve
+        action: JSON.pretty_generate(action_payload),
+        private: false
+      )
+    end
+  end
+end

data/app/services/collavre/notion_client.rb

@@ -0,0 +1,231 @@
+module Collavre
+  class NotionClient
+    BASE_URL = "https://api.notion.com/v1"
+    API_VERSION = "2022-06-28"
+
+    def initialize(account)
+      @account = account
+      @token = account.token
+    end
+
+    def search_pages(query: nil, start_cursor: nil, page_size: 10)
+      Rails.logger.info("NotionClient: Searching for pages with query: #{query}, page_size: #{page_size}")
+
+      body = {
+        filter: { property: "object", value: "page" },
+        page_size: page_size
+      }
+      body[:query] = query if query.present?
+      body[:start_cursor] = start_cursor if start_cursor.present?
+
+      Rails.logger.info("NotionClient: Search request body: #{body.to_json}")
+      result = post("search", body)
+      Rails.logger.info("NotionClient: Search returned #{result["results"]&.length || 0} results")
+      result
+    end
+
+    def get_page(page_id)
+      get("pages/#{format_id(page_id)}")
+    end
+
+    def create_page(parent_id:, title:, blocks: [])
+      Rails.logger.info("NotionClient: Creating page with #{blocks.length} blocks")
+
+      # Notion limits page creation to 100 blocks, so create with minimal content first
+      body = {
+        parent: { page_id: parent_id },
+        properties: {
+          title: {
+            title: [ { text: { content: title } } ]
+          }
+        },
+        children: blocks.length > 100 ? [] : blocks
+      }
+
+      response = post("pages", body)
+
+      # If we have more than 100 blocks, add them in batches after page creation
+      if blocks.length > 100
+        Rails.logger.info("NotionClient: Adding #{blocks.length} blocks in batches (100 per batch)")
+        page_id = response["id"]
+        Rails.logger.info("NotionClient: Created page ID: #{page_id}")
+
+        # Give Notion a moment to fully create the page
+        sleep(1)
+
+        # Add blocks in batches of 100
+        blocks.each_slice(100).with_index do |block_batch, index|
+          Rails.logger.info("NotionClient: Adding batch #{index + 1} with #{block_batch.length} blocks")
+          append_blocks(page_id, block_batch)
+          Rails.logger.info("NotionClient: Successfully added batch #{index + 1}")
+        end
+      end
+
+      response
+    end
+
+    def update_page(page_id, properties: {}, blocks: nil)
+      body = { properties: properties }
+      response = patch("pages/#{format_id(page_id)}", body)
+
+      if blocks.present?
+        replace_page_blocks(page_id, blocks)
+      end
+
+      response
+    end
+
+    def get_page_blocks(page_id, start_cursor: nil, page_size: 100)
+      params = { page_size: page_size }
+      params[:start_cursor] = start_cursor if start_cursor.present?
+
+      get("blocks/#{format_id(page_id)}/children", params)
+    end
+
+    def replace_page_blocks(page_id, blocks)
+      Rails.logger.info("NotionClient: Replacing page blocks with #{blocks.length} blocks")
+
+      # First, get existing blocks
+      existing_blocks = get_page_blocks(page_id)
+
+      # Delete existing blocks
+      existing_blocks.dig("results")&.each do |block|
+        delete_block(block["id"])
+      end
+
+      # Add new blocks in batches of 100
+      if blocks.any?
+        blocks.each_slice(100).with_index do |block_batch, index|
+          Rails.logger.info("NotionClient: Adding replacement batch #{index + 1} with #{block_batch.length} blocks")
+          append_blocks(page_id, block_batch)
+        end
+      end
+    end
+
+    def append_blocks(page_id, blocks)
+      # Notion also limits append operations to 100 blocks
+      if blocks.length > 100
+        Rails.logger.info("NotionClient: Appending #{blocks.length} blocks in batches")
+        aggregated_results = []
+
+        blocks.each_slice(100).with_index do |block_batch, index|
+          Rails.logger.info("NotionClient: Appending batch #{index + 1} with #{block_batch.length} blocks")
+          response = patch("blocks/#{format_id(page_id)}/children", { children: block_batch })
+
+          if response.is_a?(Hash)
+            batch_results = response.fetch("results", [])
+            aggregated_results.concat(batch_results) if batch_results.any?
+          end
+        end
+
+        aggregated_results.any? ? { "results" => aggregated_results } : nil
+      else
+        patch("blocks/#{format_id(page_id)}/children", { children: blocks })
+      end
+    end
+
+    def delete_block(block_id)
+      delete("blocks/#{format_id(block_id)}")
+    end
+
+    def get_workspace
+      get("users/me")
+    end
+
+    private
+
+    def get(path, params = {})
+      url = "#{BASE_URL}/#{path}"
+      url += "?#{params.to_query}" if params.any?
+
+      response = HTTParty.get(
+        url,
+        headers: headers,
+        timeout: 30
+      )
+
+      handle_response(response)
+    end
+
+    def post(path, body)
+      response = HTTParty.post(
+        "#{BASE_URL}/#{path}",
+        headers: headers,
+        body: body.to_json,
+        timeout: 30
+      )
+
+      handle_response(response)
+    end
+
+    def patch(path, body)
+      response = HTTParty.patch(
+        "#{BASE_URL}/#{path}",
+        headers: headers,
+        body: body.to_json,
+        timeout: 30
+      )
+
+      handle_response(response)
+    end
+
+    def delete(path)
+      response = HTTParty.delete(
+        "#{BASE_URL}/#{path}",
+        headers: headers,
+        timeout: 30
+      )
+
+      handle_response(response)
+    end
+
+    def headers
+      {
+        "Authorization" => "Bearer #{@token}",
+        "Notion-Version" => API_VERSION,
+        "Content-Type" => "application/json"
+      }
+    end
+
+    def format_id(id)
+      # Keep dashes in UUIDs - Notion API expects them
+      id.to_s
+    end
+
+    def handle_response(response)
+      Rails.logger.info("Notion API Response: #{response.code} for #{response.request.last_uri}")
+      Rails.logger.debug("Notion API Response Body: #{response.body}")
+
+      case response.code
+      when 200, 201
+        response.parsed_response
+      when 400
+        Rails.logger.error("Notion API 400 error: #{response.body}")
+        raise NotionError, "Bad request: #{response.parsed_response}"
+      when 401
+        Rails.logger.error("Notion API 401 error: #{response.body}")
+        raise NotionAuthError, "Unauthorized: Token may be expired"
+      when 403
+        Rails.logger.error("Notion API 403 error: #{response.body}")
+        raise NotionError, "Forbidden: Insufficient permissions"
+      when 404
+        Rails.logger.error("Notion API 404 error: #{response.body}")
+        raise NotionError, "Resource not found"
+      when 429
+        Rails.logger.error("Notion API 429 error: #{response.body}")
+        raise NotionRateLimitError, "Rate limit exceeded"
+      else
+        Rails.logger.error("Notion API error: #{response.code} #{response.body}")
+        raise NotionError, "API error: #{response.code}"
+      end
+    rescue HTTParty::Error, SocketError, Timeout::Error => e
+      Rails.logger.error("Notion API connection error: #{e.message}")
+      raise NotionConnectionError, "Connection failed: #{e.message}"
+    end
+  end
+
+  class NotionError < StandardError; end
+  class NotionAuthError < NotionError; end
+  class NotionRateLimitError < NotionError; end
+  class NotionConnectionError < NotionError; end
+end