collavre 0.1.0

data/app/services/collavre/notion_creative_exporter.rb

@@ -0,0 +1,296 @@
+module Collavre
+  class NotionCreativeExporter
+    include CreativesHelper
+
+    def initialize(creative, with_progress: false)
+      @creative = creative
+      @with_progress = with_progress
+    end
+
+    def export_blocks
+      convert_creative_to_blocks(@creative, level: 1)
+    end
+
+    def export_tree_blocks(creatives, level = 1, bullet_depth = 0)
+      return [] if creatives.blank?
+
+      blocks = []
+      creatives.each do |creative|
+        # Convert the creative to blocks
+        creative_blocks = convert_creative_to_blocks(creative, level: level)
+
+        # Handle children based on the level
+        if creative.respond_to?(:children) && creative.children.present?
+          if level > 3
+            # For bullet points (level > 3), limit nesting depth to 2 levels max
+            text_content = extract_text_content(creative.effective_description(nil, true).gsub(/<!--.*?-->/m, "").strip)
+
+            if bullet_depth < 2
+              # Can still nest deeper
+              children_blocks = export_tree_blocks(creative.children, level + 1, bullet_depth + 1)
+              bullet_block = create_bulleted_list_item_block(text_content, children_blocks)
+              blocks << bullet_block
+            else
+              # Max depth reached, flatten remaining levels
+              bullet_block = create_bulleted_list_item_block(text_content)
+              blocks << bullet_block
+              # Add children as flat bullet points at same level
+              blocks.concat(export_tree_blocks(creative.children, level, bullet_depth))
+            end
+          else
+            # For headings (level <= 3), add heading then children as separate blocks
+            blocks.concat(creative_blocks)
+            blocks.concat(export_tree_blocks(creative.children, level + 1, 0))
+          end
+        else
+          # No children, just add the blocks
+          blocks.concat(creative_blocks)
+        end
+      end
+
+      blocks
+    end
+
+    private
+
+    def convert_creative_to_blocks(creative, level: 1)
+      blocks = []
+      description_content = creative.effective_description(nil, true)
+      desc = description_content.present? ? description_content.to_s : ""
+
+      # Add progress if requested and available
+      if @with_progress && creative.respond_to?(:progress) && !creative.progress.nil?
+        pct = (creative.progress.to_f * 100).round
+        desc = "#{desc} (#{pct}%)"
+      end
+
+      # Clean HTML and prepare content
+      raw_html = desc.gsub(/<!--.*?-->/m, "").strip
+
+      # Handle different content types
+      if level <= 3 && contains_table?(raw_html)
+        blocks.concat(convert_table_to_blocks(raw_html))
+      elsif level <= 3
+        # Use as heading
+        text_content = extract_text_content(raw_html)
+        if text_content.present?
+          blocks << create_heading_block(text_content, level)
+        end
+      else
+        # Use as bulleted list item for deeper levels
+        text_content = extract_text_content(raw_html)
+        if text_content.present?
+          blocks << create_bulleted_list_item_block(text_content)
+        end
+      end
+
+      # Handle rich content like images and links within the HTML
+      blocks.concat(convert_rich_content_to_blocks(raw_html))
+
+      blocks
+    end
+
+    def contains_table?(html)
+      html.match?(%r{<table\b[^>]*>.*?</table>}im) ||
+        html.match?(/^\s*\|.*?\|(?:\s*\n\s*\|.*?\|)*\s*$/m)
+    end
+
+    def convert_table_to_blocks(html)
+      blocks = []
+
+      # Extract table content
+      table_match = html.match(%r{<table\b[^>]*>(.*?)</table>}im)
+      if table_match
+        table_html = table_match[1]
+        table_data = parse_html_table(table_html)
+        if table_data.any?
+          blocks << create_table_block(table_data)
+        end
+      else
+        # Try markdown table format
+        markdown_table = extract_markdown_table(html)
+        if markdown_table
+          table_data = parse_markdown_table(markdown_table)
+          if table_data.any?
+            blocks << create_table_block(table_data)
+          end
+        end
+      end
+
+      blocks
+    end
+
+    def parse_html_table(table_html)
+      fragment = Nokogiri::HTML::DocumentFragment.parse("<table>#{table_html}</table>")
+      table = fragment.at_css("table")
+      return [] unless table
+
+      rows = []
+      table.css("tr").each do |row|
+        cells = row.css("th,td").map do |cell|
+          text = extract_text_content(cell.inner_html)
+          create_table_cell_content(text)
+        end
+        rows << cells if cells.any?
+      end
+
+      rows
+    end
+
+    def parse_markdown_table(table_text)
+      lines = table_text.strip.split("\n").map(&:strip)
+      return [] if lines.length < 2
+
+      rows = []
+      lines.each_with_index do |line, index|
+        next if index == 1 # Skip alignment row
+
+        cells = line.split("|").map(&:strip).reject(&:empty?)
+        next if cells.empty?
+
+        cell_contents = cells.map { |cell| create_table_cell_content(cell.strip) }
+        rows << cell_contents
+      end
+
+      rows
+    end
+
+    def extract_markdown_table(html)
+      # Look for markdown table patterns in the HTML
+      html.match(/(\|.*?\|(?:\s*\n\s*\|.*?\|)*)/m)&.captures&.first
+    end
+
+    def convert_rich_content_to_blocks(html)
+      blocks = []
+
+      # Extract images
+      html.scan(%r{<action-text-attachment ([^>]+)>(?:</action-text-attachment>)?}) do |match|
+        attrs = Hash[match[0].scan(/(\S+?)="([^"]*)"/)]
+        sgid = attrs["sgid"]
+        caption = attrs["caption"] || ""
+
+        if (blob = GlobalID::Locator.locate_signed(sgid, for: "attachable"))
+          # For now, we'll create a paragraph with the image description
+          # In a full implementation, you'd upload to Notion's file storage
+          blocks << create_paragraph_block("📷 #{caption.presence || 'Image attachment'}")
+        end
+      end
+
+      # Extract data URLs for images
+      html.scan(/<img [^>]*src=['"](data:[^'"]+)['"][^>]*alt=['"]([^'"]*)['"][^>]*>/) do |data_url, alt_text|
+        blocks << create_paragraph_block("📷 #{alt_text.presence || 'Image'}")
+      end
+
+      blocks
+    end
+
+    def extract_text_content(html)
+      # Remove HTML tags and get plain text
+      ActionView::Base.full_sanitizer.sanitize(html).strip
+    end
+
+    def create_heading_block(text, level)
+      # Notion supports heading_1, heading_2, heading_3
+      heading_type = case level
+      when 1 then "heading_1"
+      when 2 then "heading_2"
+      else "heading_3"
+      end
+
+      heading_key = heading_type.to_sym
+
+      {
+        object: "block",
+        type: heading_type,
+        heading_key => {
+          rich_text: [ create_rich_text(text) ]
+        }
+      }
+    end
+
+    def create_paragraph_block(text)
+      {
+        object: "block",
+        type: "paragraph",
+        paragraph: {
+          rich_text: [ create_rich_text(text) ]
+        }
+      }
+    end
+
+    def create_bulleted_list_item_block(text, children_blocks = [])
+      block = {
+        object: "block",
+        type: "bulleted_list_item",
+        bulleted_list_item: {
+          rich_text: [ create_rich_text(text) ]
+        }
+      }
+
+      # Add nested children if present
+      if children_blocks.any?
+        block[:bulleted_list_item][:children] = children_blocks
+      end
+
+      block
+    end
+
+    def create_table_block(table_data)
+      return nil if table_data.empty?
+
+      # Notion tables need consistent column count
+      max_columns = table_data.map(&:length).max
+      normalized_rows = table_data.map do |row|
+        row + Array.new([ max_columns - row.length, 0 ].max) { create_table_cell_content("") }
+      end
+
+      {
+        object: "block",
+        type: "table",
+        table: {
+          table_width: max_columns,
+          has_column_header: true,
+          has_row_header: false,
+          children: normalized_rows.map do |row_data|
+            {
+              object: "block",
+              type: "table_row",
+              table_row: {
+                cells: row_data
+              }
+            }
+          end
+        }
+      }
+    end
+
+    def create_table_cell_content(text)
+      [ create_rich_text(text.to_s) ]
+    end
+
+    def create_rich_text(text)
+      # Notion has a 2000 character limit per text block
+      content = text.to_s.strip
+      if content.length > 1990  # Be conservative to account for any extra characters
+        original_length = content.length
+        content = content[0..1986] + "..."  # 1987 + 3 = 1990 chars
+        Rails.logger.warn("NotionCreativeExporter: Truncated content from #{original_length} to #{content.length} characters")
+      end
+
+      {
+        type: "text",
+        text: {
+          content: content
+        },
+        annotations: {
+          bold: false,
+          italic: false,
+          strikethrough: false,
+          underline: false,
+          code: false,
+          color: "default"
+        }
+      }
+    end
+  end
+end

data/app/services/collavre/notion_service.rb

@@ -0,0 +1,249 @@
+module Collavre
+  require "digest"
+
+  class NotionService
+    def initialize(user:)
+      @user = user
+      @account = user.notion_account
+      raise NotionAuthError, "No Notion account found" unless @account
+    end
+
+    def client
+      @client ||= NotionClient.new(@account)
+    end
+
+    def search_pages(query: nil, start_cursor: nil, page_size: 10)
+      with_token_refresh { client.search_pages(query: query, start_cursor: start_cursor, page_size: page_size) }
+    end
+
+    def get_page(page_id)
+      with_token_refresh { client.get_page(page_id) }
+    end
+
+    def create_page(parent_id:, title:, blocks: [])
+      with_token_refresh { client.create_page(parent_id: parent_id, title: title, blocks: blocks) }
+    end
+
+    def update_page(page_id, properties: {}, blocks: nil)
+      with_token_refresh { client.update_page(page_id, properties: properties, blocks: blocks) }
+    end
+
+    def get_page_blocks(page_id, start_cursor: nil, page_size: 100)
+      with_token_refresh { client.get_page_blocks(page_id, start_cursor: start_cursor, page_size: page_size) }
+    end
+
+    def replace_page_blocks(page_id, blocks)
+      with_token_refresh { client.replace_page_blocks(page_id, blocks) }
+    end
+
+    def append_blocks(parent_id, blocks)
+      with_token_refresh { client.append_blocks(parent_id, blocks) }
+    end
+
+    def delete_block(block_id)
+      with_token_refresh { client.delete_block(block_id) }
+    end
+
+    def get_workspace
+      with_token_refresh { client.get_workspace }
+    end
+
+    # Create or update a page for a creative
+    def sync_creative(creative, parent_page_id: nil)
+      notion_link = find_or_create_page_link(creative, parent_page_id)
+
+      if notion_link.page_id.present?
+        # Update existing page
+        update_creative_page(creative, notion_link)
+      else
+        # Create new page
+        create_creative_page(creative, notion_link, parent_page_id)
+      end
+
+      notion_link.mark_synced!
+      notion_link
+    end
+
+    private
+
+    def with_token_refresh(&block)
+      yield
+    rescue NotionAuthError => e
+      if refresh_token!
+        @client = nil # Reset client with new token
+        yield
+      else
+        raise e
+      end
+    end
+
+    def refresh_token!
+      # Notion uses OAuth 2.0 but doesn't issue refresh tokens in the same way as Google
+      # For now, we'll just log the error and return false
+      # In a production app, you'd implement proper token refresh logic here
+      Rails.logger.error("Notion token refresh needed but not implemented")
+      false
+    end
+
+    def find_or_create_page_link(creative, parent_page_id)
+      @account.notion_page_links.find_or_initialize_by(creative: creative) do |link|
+        link.parent_page_id = parent_page_id
+      end
+    end
+
+    def create_creative_page(creative, notion_link, parent_page_id)
+      title = ActionController::Base.helpers.strip_tags(creative.description).strip.presence || "Untitled Creative"
+
+      # Export only the children - the page title serves as the root creative
+      children = creative.children.to_a
+      Rails.logger.info("NotionService: Exporting creative #{creative.id} as page title with #{children.count} children as blocks")
+
+      exporter = NotionCreativeExporter.new(creative)
+      blocks = []
+
+      # If no parent specified, search for a suitable workspace page
+      parent_page_id ||= find_default_parent_page
+
+      response = create_page(
+        parent_id: parent_page_id,
+        title: title,
+        blocks: blocks
+      )
+
+      notion_link.update!(
+        page_id: response["id"],
+        page_title: title,
+        page_url: response["url"],
+        parent_page_id: parent_page_id
+      )
+
+      sync_child_blocks(notion_link, creative, children, exporter)
+
+      response
+    end
+
+    def update_creative_page(creative, notion_link)
+      title = ActionController::Base.helpers.strip_tags(creative.description).strip.presence || "Untitled Creative"
+
+      # Update with only the children - page title serves as the root creative
+      children = creative.children.to_a
+      Rails.logger.info("NotionService: Updating creative #{creative.id} as page title with #{children.count} children as blocks")
+
+      exporter = NotionCreativeExporter.new(creative)
+
+      properties = {
+        title: {
+          title: [ { text: { content: title } } ]
+        }
+      }
+
+      update_page(notion_link.page_id, properties: properties)
+      notion_link.update!(page_title: title)
+
+      sync_child_blocks(notion_link, creative, children, exporter)
+    end
+
+    def find_default_parent_page
+      # Search for pages in the workspace to find a suitable parent
+      pages = search_pages(page_size: 1)
+      pages.dig("results")&.first&.dig("id") || raise(NotionError, "No accessible pages found in workspace")
+    end
+
+    def sync_child_blocks(notion_link, creative, children, exporter)
+      child_ids = children.map(&:id)
+      existing_links = notion_link.notion_block_links.includes(:creative).order(:created_at).to_a
+      existing_links_by_creative = existing_links.group_by(&:creative_id)
+
+      page_blocks = existing_links.any? ? fetch_all_page_blocks(notion_link.page_id) : []
+      page_block_ids = page_blocks.map { |block| block["id"] }
+
+      block_to_creative = {}
+      existing_links.each do |link|
+        block_to_creative[link.block_id] = link.creative_id if page_block_ids.include?(link.block_id)
+      end
+
+      existing_order = page_block_ids.map { |block_id| block_to_creative[block_id] }.compact.uniq
+      expected_order = child_ids.select { |id| existing_links_by_creative.key?(id) }
+      reorder_detected = existing_order != expected_order
+
+      removed_ids = existing_links_by_creative.keys - child_ids
+      changes_detected = removed_ids.any?
+
+      child_exports = children.map do |child|
+        exported_blocks = exporter.export_tree_blocks([ child ], 1, 0)
+        content_hash = Digest::SHA256.hexdigest(exported_blocks.to_json)
+        links = existing_links_by_creative[child.id] || []
+        missing_blocks = links.any? { |link| !page_block_ids.include?(link.block_id) }
+
+        if exported_blocks.empty?
+          changes_detected ||= links.present?
+        else
+          changes_detected ||= links.blank?
+          changes_detected ||= links.size != exported_blocks.size
+          changes_detected ||= links.first.content_hash != content_hash
+          changes_detected ||= missing_blocks
+        end
+
+        {
+          child: child,
+          exported_blocks: exported_blocks,
+          content_hash: content_hash
+        }
+      end
+
+      unless changes_detected || reorder_detected
+        return
+      end
+
+      blocks_to_clear = page_blocks.presence || fetch_all_page_blocks(notion_link.page_id)
+      blocks_to_clear.each do |block|
+        begin
+          delete_block(block["id"])
+        rescue NotionError => e
+          Rails.logger.warn("NotionService: Failed to delete Notion block #{block['id']} during resync: #{e.message}")
+        end
+      end
+
+      NotionBlockLink.transaction do
+        notion_link.notion_block_links.delete_all
+
+        child_exports.each do |data|
+          exported_blocks = data[:exported_blocks]
+          next if exported_blocks.empty?
+
+          response = append_blocks(notion_link.page_id, exported_blocks)
+          response_results = response.is_a?(Hash) ? response.fetch("results", []) : []
+          new_block_ids = response_results.filter_map { |result| result["id"] }
+
+          if new_block_ids.empty?
+            Rails.logger.warn("NotionService: Unable to determine new block ids for creative #{data[:child].id}")
+            next
+          end
+
+          new_block_ids.each do |block_id|
+            notion_link.notion_block_links.create!(
+              creative: data[:child],
+              block_id: block_id,
+              content_hash: data[:content_hash]
+            )
+          end
+        end
+      end
+    end
+
+    def fetch_all_page_blocks(page_id)
+      blocks = []
+      cursor = nil
+
+      loop do
+        response = get_page_blocks(page_id, start_cursor: cursor)
+        blocks.concat(response.fetch("results", []))
+        break unless response["has_more"]
+
+        cursor = response["next_cursor"]
+      end
+
+      blocks
+    end
+  end
+end

data/app/services/collavre/ppt_importer.rb

@@ -0,0 +1,76 @@
+module Collavre
+  class PptImporter
+    # Import each slide from a PowerPoint file as HTML and create Creatives.
+    def self.import(file, parent:, user:, create_root: false, filename: nil)
+      require "zip"
+      require "nokogiri"
+      require "base64"
+      require "pathname"
+      require "erb"
+
+      created = []
+      root = parent
+      if create_root
+        title = filename ? File.basename(filename, File.extname(filename)) : "Presentation"
+        root = Creative.create(user: user, parent: parent, description: ERB::Util.html_escape(title))
+        created << root
+      end
+
+      Zip::File.open(file) do |zip|
+        slide_entries = zip.glob("ppt/slides/slide*.xml").sort_by do |entry|
+          entry.name[/slide(\d+)/, 1].to_i
+        end
+
+        slide_entries.each do |entry|
+          slide_number = entry.name[/slide(\d+)/, 1]
+          xml = Nokogiri::XML(entry.get_input_stream.read)
+          ns = xml.collect_namespaces
+          html_fragments = []
+
+          # Extract paragraphs as HTML
+          xml.xpath("//p:sp//a:p", ns).each do |p_node|
+            text = p_node.xpath(".//a:t", ns).map(&:text).join
+            next if text.strip.empty?
+            html_fragments << "<p>#{ERB::Util.html_escape(text)}</p>"
+          end
+
+          # Map relationship IDs to targets for image lookup
+          rels_name = "ppt/slides/_rels/slide#{slide_number}.xml.rels"
+          relationships = {}
+          if (rels_entry = zip.find_entry(rels_name))
+            rel_xml = Nokogiri::XML(rels_entry.get_input_stream.read)
+            rel_xml.xpath("//xmlns:Relationship").each do |rel|
+              relationships[rel["Id"]] = rel["Target"]
+            end
+          end
+
+          # Extract images and embed as base64 data URLs
+          xml.xpath("//p:pic", ns).each do |pic|
+            blip = pic.at_xpath(".//a:blip", ns)
+            next unless blip
+            embed_id = blip["r:embed"]
+            target = relationships[embed_id]
+            next unless target
+            img_path = Pathname.new("ppt/slides").join(target).cleanpath.to_s
+            img_entry = zip.find_entry(img_path)
+            next unless img_entry
+            data = img_entry.get_input_stream.read
+            mime = case File.extname(img_path).downcase
+            when ".png" then "image/png"
+            when ".jpg", ".jpeg" then "image/jpeg"
+            when ".gif" then "image/gif"
+            else "application/octet-stream"
+            end
+            base64 = Base64.strict_encode64(data)
+            html_fragments << "<img src=\"data:#{mime};base64,#{base64}\" />"
+          end
+
+          c = Creative.create(user: user, parent: root, description: html_fragments.join)
+          created << c
+        end
+      end
+
+      created
+    end
+  end
+end

data/app/services/collavre/ruby_llm_interaction_logger.rb

@@ -0,0 +1,34 @@
+module Collavre
+  # frozen_string_literal: true
+
+  class RubyLlmInteractionLogger
+    class << self
+      def log(vendor:, model:, messages:, tools: [], response_content: nil, error_message: nil, activity: "llm_query", creative: nil, user: nil, comment: nil, input_tokens: nil, output_tokens: nil)
+        ActivityLog.create!(
+          activity: activity,
+          creative: creative,
+          user: user,
+          comment: comment,
+          log: {
+            vendor: vendor.presence || "unknown",
+            model: model.to_s,
+            messages: safe_json(messages || []),
+            tools: safe_json(tools || []),
+            response_content: response_content,
+            error_message: error_message,
+            input_tokens: input_tokens,
+            output_tokens: output_tokens
+          }
+        )
+      rescue StandardError => e
+        Rails.logger.error("Failed to persist activity log: #{e.class} #{e.message}")
+      end
+
+      private
+
+      def safe_json(value)
+        JSON.parse(value.to_json)
+      end
+    end
+  end
+end

data/app/services/collavre/system_events/context_builder.rb

@@ -0,0 +1,41 @@
+module Collavre
+  module SystemEvents
+    class ContextBuilder
+      def initialize(context)
+        @context = context
+      end
+
+      def build
+        # Ensure context is a hash with string keys for Liquid
+        ctx = @context.deep_stringify_keys
+
+        # Add helper objects/functions
+        if ctx["chat"]
+          ctx["chat"]["mentioned_user"] ||= mentioned_user(ctx["chat"])
+        end
+
+        ctx
+      end
+
+      private
+
+      def mentioned_user(chat_context)
+        # This mimics the chat.mentioned_user function requested
+        # It assumes chat_context has 'content' or similar, or we might need to look up the comment
+        # For now, let's assume the context passed in already has the necessary info or we extract it.
+        # If the event is comment_created, the payload usually has the comment content.
+
+        content = chat_context["content"]
+        return nil unless content
+
+        # Simple regex to find the first mention
+        match = content.match(/\A@([^:]+?):\s*/) || content.match(/\A@(\S+)\s+/)
+        return nil unless match
+
+        name = match[1].strip
+        user = User.where("LOWER(name) = ?", name.downcase).first
+        user&.as_json(only: [ :id, :name, :email ])
+      end
+    end
+  end
+end