collavre 0.1.0

data/app/models/collavre/webauthn_credential.rb

@@ -0,0 +1,11 @@
+module Collavre
+  class WebauthnCredential < ApplicationRecord
+    self.table_name = "webauthn_credentials"
+
+    belongs_to :user, class_name: "Collavre::User"
+
+    validates :webauthn_id, presence: true, uniqueness: true
+    validates :public_key, presence: true
+    validates :sign_count, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+  end
+end

data/app/services/collavre/ai_agent_service.rb

@@ -0,0 +1,193 @@
+module Collavre
+  class AiAgentService
+    def initialize(task)
+      @task = task
+      @agent = task.agent
+      @context = task.trigger_event_payload
+    end
+
+    def call
+      Current.set(user: @agent) do
+        # Log start action
+        log_action("start", { message: "Starting agent execution" })
+
+        # Prepare messages for AI
+        messages = build_messages
+
+        # Log prompt generation
+        log_action("prompt_generated", { messages: messages })
+
+        # Call AI Client
+        response_content = ""
+
+        # Enrich context for rendering
+        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
+
+        rendered_system_prompt = AiSystemPromptRenderer.new(
+          template: @agent.system_prompt,
+          context: rendering_context
+        ).render
+
+        # 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
+        end
+
+        # we may pass event payload also to the AI client for more context if needed - TODO
+        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,
+            user: @agent,
+            comment: reply_comment || (@context.dig("comment", "id") ? Comment.find_by(id: @context["comment"]["id"]) : nil)
+          }
+        )
+
+        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")
+          end
+        end
+
+        # Log completion
+        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 })
+          else
+            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)
+        end
+      end
+    end
+
+    private
+
+    def log_action(type, payload, result = nil)
+      @task.task_actions.create!(
+        action_type: type,
+        payload: payload,
+        result: result,
+        status: "done"
+      )
+    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)
+          if creative
+            markdown = ApplicationController.helpers.render_creative_tree_markdown([ creative ], 1, true)
+            messages << { role: "user", parts: [ { text: "Creative:\n#{markdown}" } ] }
+          end
+        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
+
+        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
+               .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)
+
+          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
+          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 } ] }
+
+      messages
+    end
+
+    def reply_to_comment(comment_id, content)
+      original_comment = Comment.find_by(id: comment_id)
+      return unless original_comment
+
+      reply = original_comment.creative.comments.create!(
+        content: content,
+        user: @agent,
+        topic_id: original_comment.topic_id
+      )
+
+      log_action("reply_created", { comment_id: reply.id, content: content })
+    end
+  end
+end

data/app/services/collavre/ai_client.rb

@@ -0,0 +1,183 @@
+module Collavre
+  class AiClient
+    SYSTEM_INSTRUCTIONS = <<~PROMPT.freeze
+      You are a senior expert teammate. Respond:
+      - Be concise and focus on the essentials (avoid unnecessary verbosity).
+      - Use short bullet points only when helpful.
+      - State only what you're confident about; briefly note any uncertainty.
+      - Respond in the asker's language (prefer the latest user message). Keep code and error messages in their original form.
+    PROMPT
+
+    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
+    end
+
+    def chat(contents, tools: [], &block)
+      response_content = +""
+      error_message = nil
+      input_tokens = nil
+      output_tokens = nil
+
+      # For now, we assume the API key is in the environment variable GEMINI_API_KEY
+      # In a real generic implementation, we might need to fetch keys based on vendor.
+      # Since the user request mentioned "ruby_llm", we try to use it.
+      # However, RubyLLM configuration in this project seems to be static in initializer.
+      # We might need to adjust RubyLLM usage to be dynamic if possible, or just support Gemini for now via RubyLLM
+      # but allowing model configuration.
+
+      # Current RubyLLM initializer:
+      # RubyLLM.configure do |config|
+      #   config.gemini_api_key = ENV["GEMINI_API_KEY"]
+      # end
+
+      # We can use RubyLLM.context to override config per request if needed,
+      # but for now we'll stick to the pattern in GeminiChatClient but make it slightly more generic
+      # if RubyLLM supports other vendors.
+
+      # NOTE: The current requirement implies we should support what RubyLLM supports.
+      # If the user enters vendor='google', we use Gemini.
+
+      # For now, we assume the API key is in the environment variable GEMINI_API_KEY
+      # In a real generic implementation, we might need to fetch keys based on vendor.
+      # Since the user request mentioned "ruby_llm", we try to use it.
+      # Previously the method returned early unless vendor was "google" which caused AI responses
+      # to be omitted for agents with a different or nil vendor. We now proceed for any vendor
+      # and log a warning if the vendor is unsupported.
+
+      normalized_vendor = vendor.to_s.downcase
+      unless %w[google gemini].include?(normalized_vendor)
+        Rails.logger.warn "Unsupported LLM vendor '#{@vendor}'. Attempting to use default (google)."
+      end
+
+      conversation = build_conversation(tools)
+      add_messages(conversation, contents)
+
+      response = conversation.complete do |chunk|
+        delta = extract_chunk_content(chunk)
+        next if delta.blank?
+
+        response_content << delta
+        yield delta if block_given?
+      end
+
+      if response
+        response_content = response.content.to_s if response.content.present?
+
+        # Extract token usage directly from response object (RubyLLM style)
+        if response.respond_to?(:input_tokens)
+          input_tokens = response.input_tokens
+        end
+
+        if response.respond_to?(:output_tokens)
+          output_tokens = response.output_tokens
+        end
+      end
+
+      response_content.presence
+    rescue StandardError => e
+      error_message = e.message
+      Rails.logger.error "AI Client error: #{e.message}"
+      Rails.logger.debug e.backtrace.join("\n")
+      yield "AI Error: #{e.message}" if block_given?
+      nil
+    ensure
+      log_interaction(
+        messages: conversation.messages.to_a || Array(contents),
+        tools: conversation.tools.to_a,
+        response_content: response_content.presence,
+        error_message: error_message,
+        input_tokens: input_tokens,
+        output_tokens: output_tokens
+      )
+    end
+
+    private
+
+    attr_reader :vendor, :model, :system_prompt, :llm_api_key, :context
+
+    def build_conversation(tools = [])
+      # Using RubyLLM.context to ensure we can potentially switch keys if we had them.
+      # We explicitly set the key from ENV for now, as RubyLLM might not pick it up from global config in context?
+      # Or maybe the global config was not loaded in the runner context properly?
+      # Regardless, setting it here ensures it works like GeminiChatClient.
+
+      api_key = @llm_api_key.presence || ENV["GEMINI_API_KEY"]
+      RubyLLM.context { |config| config.gemini_api_key = api_key }
+             .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)}")
+        end
+        if tools.any?
+          # Resolve tool names to classes using the gem's helper
+          tool_classes = ::Tools::MetaToolService.ruby_llm_tools(tools)
+          chat.with_tools(*tool_classes, replace: true)
+        end
+      end
+    end
+
+    def add_messages(conversation, contents)
+      Array(contents).each do |message|
+        next if message.nil?
+
+        role = normalize_role(message)
+        next unless role
+
+        text = extract_message_text(message)
+        next if text.blank?
+
+        conversation.add_message(role:, content: text)
+      end
+    end
+
+    def normalize_role(message)
+      value = message[:role] || message["role"]
+      case value.to_s
+      when "user" then :user
+      when "model", "assistant" then :assistant
+      when "system" then :system
+      when "function", "tool" then :tool
+      else
+        nil
+      end
+    end
+
+    def extract_message_text(message)
+      parts = message[:parts] || message["parts"]
+      return message[:text] || message["text"] if parts.nil?
+
+      Array(parts).map { |part| part[:text] || part["text"] }.compact.join("\n")
+    end
+
+    def extract_chunk_content(chunk)
+      return if chunk.nil?
+
+      if chunk.respond_to?(:content)
+        chunk.content
+      else
+        chunk.to_s
+      end
+    end
+
+    def log_interaction(messages:, tools:, response_content:, error_message: nil, input_tokens: nil, output_tokens: nil)
+      RubyLlmInteractionLogger.log(
+        vendor: @vendor,
+        model: @model,
+        messages: messages,
+        tools: tools,
+        response_content: response_content,
+        error_message: error_message,
+        creative: context&.dig(:creative),
+        user: context&.dig(:user),
+        comment: context&.dig(:comment),
+        input_tokens: input_tokens,
+        output_tokens: output_tokens
+      )
+    end
+  end
+end

data/app/services/collavre/ai_system_prompt_renderer.rb

@@ -0,0 +1,38 @@
+module Collavre
+  class AiSystemPromptRenderer
+    def self.render(template:, context: {})
+      new(template:, context:).render
+    end
+
+    def initialize(template:, context: {})
+      @template = template.presence || AiClient::SYSTEM_INSTRUCTIONS
+      @context = context
+    end
+
+    def render
+      parsed_template.render(stringified_context, render_options)
+    rescue StandardError => e
+      Rails.logger.warn("AI system prompt rendering failed: #{e.message}")
+      template
+    end
+
+    private
+
+    attr_reader :template, :context
+
+    def parsed_template
+      Liquid::Template.parse(template, error_mode: :warn)
+    end
+
+    def stringified_context
+      context.deep_stringify_keys
+    end
+
+    def render_options
+      {
+        strict_variables: false,
+        strict_filters: false
+      }
+    end
+  end
+end

data/app/services/collavre/auto_theme_generator.rb

@@ -0,0 +1,198 @@
+module Collavre
+  class AutoThemeGenerator
+    REQUIRED_VARIABLES = %w[
+      --color-bg
+      --color-text
+      --color-link
+      --color-nav-bg
+      --color-section-bg
+      --color-btn-bg
+      --color-btn-text
+      --color-border
+      --color-muted
+      --color-complete
+      --color-chip-bg
+      --color-drag-over
+      --color-drag-over-edge
+      --hover-brightness
+      --color-badge-bg
+      --color-badge-text
+      --color-secondary-active
+      --color-secondary-background
+      --color-nav-btn-text
+      --color-chat-btn-text
+      --color-input-bg
+      --color-input-text
+      --color-nav-text
+      --creative-loading-emojis
+    ].freeze
+
+    def initialize(client: default_client)
+      @client = client
+    end
+
+    def generate(prompt)
+      system_prompt = <<~PROMPT
+        You are an expert UI/UX designer specialized in creating color themes for web applications.
+        Your task is to generate a JSON object containing CSS variables.
+        Generate a CSS theme as a JSON object based on the prompt: "#{prompt}".
+        The JSON must strictly contain ONLY these keys: #{REQUIRED_VARIABLES.join(', ')}.
+
+        CRITICAL DESIGN RULES:
+        1. Use **only 'oklch()' color format** for all colors. Do not use hex, rgb, or hsl.
+        2. Ensure "--color-nav-btn-text" has High Contrast (WCAG AA/AAA) against "--color-bg" (which is used as the button background in the nav).
+        3. Ensure "--color-chat-btn-text" has High Contrast against "--color-section-bg" (where chat messages reside).
+        4. Ensure "--color-nav-text" has High Contrast against "--color-nav-bg".
+        5. Names of these text colors should be visually distinct from their background colors to ensure readability.
+        6. For "--creative-loading-emojis", provide a comma-separated string of exactly 6 emojis that match the theme mood (e.g., "🌵,🏜️,☀️,🦎,🌾,🐪").
+        7. Do not include any other keys or newlines.
+        8. Return valid JSON only.
+
+        The JSON object must strictly follow this structure:
+        {
+          "--color-bg": "oklch(95% 0.01 200)",
+          "--color-text": "oklch(20% 0.02 200)",
+          ...
+        }
+
+        REQUIRED VARIABLES:
+        #{REQUIRED_VARIABLES.join("\n")}
+
+        GUIDELINES:
+        - Ensure high contrast between text and background.
+        - Maintain a consistent aesthetic suitable for the description.
+        - Return ONLY the JSON object. No markdown formatting, no explanations.
+      PROMPT
+
+      response = @client.chat([
+        { role: :system, parts: [ { text: system_prompt } ] },
+        { role: :user, parts: [ { text: "Create a theme description: #{prompt}" } ] }
+      ])
+
+      parse_response(response)
+    end
+
+    private
+
+    def default_client
+      AiClient.new(
+        vendor: "google",
+        model: "gemini-2.5-flash",
+        system_prompt: nil
+      )
+    end
+
+    def parse_response(content)
+      return {} if content.blank?
+
+      # Remove markdown code blocks if present
+      cleaned = content.gsub(/^```json\s*/, "").gsub(/\s*```$/, "")
+
+      parsed = begin
+        JSON.parse(cleaned)
+      rescue JSON::ParserError => e
+        Rails.logger.error("AutoThemeGenerator JSON Error: #{e.message}. Content: #{content}")
+        {}
+      end
+
+      return {} unless parsed.is_a?(Hash)
+
+      process_variables(parsed)
+    end
+
+    def process_variables(variables)
+      variables.transform_values do |value|
+        if value.is_a?(String) && value.start_with?("oklch(")
+          convert_oklch_to_hex(value)
+        else
+          value
+        end
+      end
+    end
+
+    def convert_oklch_to_hex(oklch_str)
+      # Parse oklch string: oklch(L C H [/ A])
+      # Supports %, deg, and alpha channel
+      # Example: oklch(60% 0.15 240deg / 0.5)
+      # Regex matches:
+      # 1. Lightness (number + optional %)
+      # 2. Chroma (number + optional %)
+      # 3. Hue (number + optional deg/rad/turn)
+      # 4. Optional alpha (number + optional %)
+      match = oklch_str.match(/oklch\(\s*([0-9.]+)%?\s+([0-9.]+)%?\s+([0-9.]+)(?:deg|rad|turn)?(?:\s*\/\s*([0-9.]+)%?)?\s*\)/)
+      return oklch_str unless match
+
+      l_val = match[1].to_f
+      l_val /= 100.0 if oklch_str.include?("#{match[1]}%") && !match[1].include?(".") # Simple heuristic, or trust regex groups if I separated units.
+      # Better to just handle the % if it was captured. My regex captures the number part separate from %.
+      # Actually, the regex above `([0-9.]+)%?` captures ONLY the number in group 1.
+      # So I need to check if the original string had % for that match.
+      # Let's refine parsing.
+
+      # Re-parsing carefully
+      l_raw = match[1]
+      l_val = l_raw.to_f
+      l_val /= 100.0 if oklch_str =~ /#{Regexp.escape(l_raw)}%/
+
+      c_val = match[2].to_f
+      # Chroma usually doesn't have %, but if it does (rare), handle it? Standard is number.
+      # Let's assume number.
+
+      h_val = match[3].to_f
+      # Hue is usually degrees if unitless or deg.
+      # If rad/turn, conversion needed? Standard oklch is degrees-like?
+      # CSS spec says oklch hue is angle. Deg is default.
+
+      # Alpha: match[4]
+      # We are currently ignoring alpha for 6-digit hex output.
+
+      # 1. OKLCH to OKLab
+      # h is in degrees, convert to radians
+      h_rad = h_val * Math::PI / 180.0
+      a_val = c_val * Math.cos(h_rad)
+      b_val = c_val * Math.sin(h_rad)
+
+      # 2. OKLab to Linear sRGB
+      # Matrix values from standard implementation
+      # Step 1: Lab to LMS (non-linear)
+      l_non_linear = l_val + 0.3963377774 * a_val + 0.2158037573 * b_val
+      m_non_linear = l_val - 0.1055613458 * a_val - 0.0638541728 * b_val
+      s_non_linear = l_val - 0.0894841775 * a_val - 1.2914855480 * b_val
+
+      # Step 2: Cube to get Linear LMS
+      l = l_non_linear ** 3
+      m = m_non_linear ** 3
+      s = s_non_linear ** 3
+
+      # Step 3: LMS to Linear sRGB
+      r_linear = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s
+      g_linear = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s
+      b_linear = -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s
+
+      # 3. Linear sRGB to sRGB (Gamma correction)
+      r = linear_srgb_to_srgb(r_linear)
+      g = linear_srgb_to_srgb(g_linear)
+      b = linear_srgb_to_srgb(b_linear)
+
+      # 4. To Hex
+      to_hex(r, g, b)
+    end
+
+    def linear_srgb_to_srgb(c)
+      val = if c <= 0.0031308
+              12.92 * c
+      else
+              1.055 * (c ** (1.0 / 2.4)) - 0.055
+      end
+      # Clamp between 0 and 1
+      [ [ val, 0.0 ].max, 1.0 ].min
+    end
+
+    def to_hex(r, g, b)
+      r_int = (r * 255).round
+      g_int = (g * 255).round
+      b_int = (b * 255).round
+      sprintf("#%02x%02x%02x", r_int, g_int, b_int)
+    end
+  end
+end

data/app/services/collavre/comment_link_formatter.rb

@@ -0,0 +1,60 @@
+module Collavre
+  require "uri"
+
+  class CommentLinkFormatter
+    URL_REGEX = URI::DEFAULT_PARSER.make_regexp(%w[http https])
+    TRAILING_PUNCTUATION = ".,!?;:".freeze
+
+    def initialize(content, metadata_fetcher: nil, logger: Rails.logger)
+      @content = content.to_s
+      @metadata_fetcher = metadata_fetcher || method(:default_fetch_metadata)
+      @logger = logger
+    end
+
+    def format
+      return @content if @content.blank?
+
+      @content.gsub(URL_REGEX) do |match|
+        match_data = Regexp.last_match
+        url, trailing = strip_trailing_punctuation(match)
+        next match if markdown_link?(match_data.pre_match)
+
+        metadata = fetch_metadata(url)
+        title = metadata[:title].presence
+        next match if title.blank?
+
+        "[#{title}](#{url})#{trailing}"
+      end
+    end
+
+    private
+
+    def strip_trailing_punctuation(url)
+      trailing = ""
+      while url.length.positive? && TRAILING_PUNCTUATION.include?(url[-1])
+        trailing = url[-1] + trailing
+        url = url[0...-1]
+      end
+      [ url, trailing ]
+    end
+
+    def markdown_link?(pre_match)
+      return false unless pre_match
+      pre_match =~ /\[[^\]]*\]\([^)]*$/
+    end
+
+    def fetch_metadata(url)
+      @metadata_cache ||= {}
+      return @metadata_cache[url] if @metadata_cache.key?(url)
+
+      @metadata_cache[url] = @metadata_fetcher.call(url)
+    rescue StandardError => e
+      @logger&.warn("Failed to fetch link metadata for #{url}: #{e.class} #{e.message}")
+      @metadata_cache[url] = {}
+    end
+
+    def default_fetch_metadata(url)
+      LinkPreviewFetcher.fetch(url)
+    end
+  end
+end