aven 0.0.3

data/app/models/aven/chat/thread.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_chat_threads
+#
+#  id               :bigint           not null, primary key
+#  context_markdown :text
+#  documents        :jsonb
+#  title            :string
+#  tools            :jsonb
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  agent_id         :bigint
+#  user_id          :bigint           not null
+#  workspace_id     :bigint           not null
+#
+# Indexes
+#
+#  index_aven_chat_threads_on_agent_id                  (agent_id)
+#  index_aven_chat_threads_on_created_at                (created_at)
+#  index_aven_chat_threads_on_user_id                   (user_id)
+#  index_aven_chat_threads_on_workspace_id              (workspace_id)
+#  index_aven_chat_threads_on_workspace_id_and_user_id  (workspace_id,user_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (agent_id => aven_agentic_agents.id)
+#  fk_rails_...  (user_id => aven_users.id)
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  module Chat
+    class Thread < Aven::ApplicationRecord
+      self.table_name = "aven_chat_threads"
+
+      include Aven::Model::TenantModel
+
+      belongs_to :user, class_name: "Aven::User"
+      belongs_to :agent, class_name: "Aven::Agentic::Agent", optional: true
+
+      has_many :messages,
+               class_name: "Aven::Chat::Message",
+               foreign_key: :thread_id,
+               dependent: :destroy
+
+      validates :user, presence: true
+
+      after_update :broadcast_update, if: :saved_change_to_title?
+
+      scope :recent, -> { order(created_at: :desc) }
+
+      # Tools are locked on first agent use and never modified after.
+      # - nil means all tools are available (free-form chat)
+      # - Array of tool names means only those tools are available
+      def tools_locked?
+        tools.present?
+      end
+
+      # Lock tools to a specific set of tool names.
+      def lock_tools!(tool_names)
+        return if tools_locked?
+
+        update!(tools: tool_names)
+      end
+
+      # Documents are locked on first agent use and never modified after.
+      def documents_locked?
+        documents.present?
+      end
+
+      # Lock documents to a specific set of document IDs.
+      def lock_documents!(document_ids)
+        return if documents_locked?
+        return if document_ids.blank?
+
+        update!(documents: document_ids)
+      end
+
+      # Returns the locked documents with OCR content for system prompt injection
+      def locked_documents
+        return [] unless documents_locked?
+
+        Aven::Agentic::Document.where(id: documents).where(ocr_status: "completed")
+      end
+
+      # Check if thread has an agent locked
+      def agent_locked?
+        agent_id.present?
+      end
+
+      # Lock the agent reference. Called once when an agent is first used.
+      def lock_agent!(agent)
+        return if agent_locked?
+
+        update!(agent:)
+      end
+
+      # Ask a question and trigger chat processing
+      def ask(question)
+        user_message = messages.create!(
+          role: :user,
+          content: question,
+          status: :success
+        )
+        Aven::Chat::RunJob.perform_later(id, user_message.id)
+        user_message
+      end
+
+      # Ask with an agent, locking agent/tools/documents on first use
+      def ask_with_agent(agent, question = nil)
+        unless agent_locked?
+          lock_agent!(agent)
+          lock_tools!(agent.tool_names)
+          lock_documents!(agent.document_ids)
+        end
+
+        # Create hidden system message with agent's system prompt
+        if agent.system_prompt.present?
+          messages.create!(
+            role: :system,
+            content: agent.system_prompt,
+            status: :success
+          )
+        end
+
+        ask(question || agent.user_facing_question)
+      end
+
+      # Calculate usage statistics
+      def usage_stats
+        result = messages
+          .where.not(role: :user)
+          .pick(
+            Arel.sql("SUM(input_tokens)"),
+            Arel.sql("SUM(output_tokens)"),
+            Arel.sql("SUM(total_tokens)"),
+            Arel.sql("SUM(cost_usd)")
+          )
+
+        {
+          input: result[0] || 0,
+          output: result[1] || 0,
+          total: result[2] || 0,
+          cost: result[3] || 0.0
+        }
+      end
+
+      private
+
+        def broadcast_update
+          Aven::Chat::ThreadChannel.broadcast_to(self, {
+            type: "thread_update",
+            thread: { id:, title: }
+          })
+        end
+    end
+  end
+end

data/app/models/aven/import/entry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_import_entries
+#
+#  id         :bigint           not null, primary key
+#  data       :jsonb            not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#  import_id  :bigint           not null
+#
+# Indexes
+#
+#  index_aven_import_entries_on_data       (data) USING gin
+#  index_aven_import_entries_on_import_id  (import_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (import_id => aven_imports.id)
+#
+module Aven
+  class Import::Entry < ApplicationRecord
+    self.table_name = "aven_import_entries"
+
+    belongs_to :import, class_name: "Aven::Import"
+    has_many :item_links, class_name: "Aven::Import::ItemLink", foreign_key: :entry_id, dependent: :destroy
+    has_many :items, through: :item_links, class_name: "Aven::Item"
+
+    validates :data, presence: true
+
+    scope :linked, -> { joins(:item_links).distinct }
+    scope :unlinked, -> { where.missing(:item_links) }
+
+    delegate :workspace, to: :import
+
+    def linked?
+      item_links.exists?
+    end
+
+    def link_to_item!(item)
+      item_links.create!(item:)
+    end
+  end
+end

data/app/models/aven/import/item_link.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_import_item_links
+#
+#  id         :bigint           not null, primary key
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#  entry_id   :bigint           not null
+#  item_id    :bigint           not null
+#
+# Indexes
+#
+#  index_aven_import_item_links_on_entry_id              (entry_id)
+#  index_aven_import_item_links_on_entry_id_and_item_id  (entry_id,item_id) UNIQUE
+#  index_aven_import_item_links_on_item_id               (item_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (entry_id => aven_import_entries.id)
+#  fk_rails_...  (item_id => aven_items.id)
+#
+module Aven
+  class Import::ItemLink < ApplicationRecord
+    self.table_name = "aven_import_item_links"
+
+    belongs_to :entry, class_name: "Aven::Import::Entry"
+    belongs_to :item, class_name: "Aven::Item"
+
+    validates :entry_id, uniqueness: { scope: :item_id }
+
+    delegate :import, :workspace, to: :entry
+    delegate :schema_slug, to: :item
+  end
+end

data/app/models/aven/import/processor.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Aven
+  class Import::Processor
+    attr_reader :import
+
+    def initialize(import)
+      @import = import
+    end
+
+    def run
+      import.mark_processing!
+
+      import.entries.unlinked.find_each do |entry|
+        process_entry(entry)
+        import.increment_processed!
+      end
+
+      import.mark_completed!
+    rescue StandardError => e
+      import.mark_failed!(e.message)
+      raise
+    end
+
+    private
+
+      def process_entry(entry)
+        return skip_entry(entry, "No email found") if entry_email(entry).blank?
+        return skip_duplicate(entry) if duplicate?(entry)
+
+        item = create_item(entry)
+        entry.link_to_item!(item)
+        import.increment_imported!
+      rescue ActiveRecord::RecordInvalid => e
+        import.increment_skipped!
+        import.log_error("Failed to create item for entry #{entry.id}: #{e.message}")
+      end
+
+      def entry_email(entry)
+        entry.data["email"]
+      end
+
+      def duplicate?(entry)
+        email = entry_email(entry)
+        Aven::Item.by_schema(target_schema)
+                  .where(workspace_id: import.workspace_id)
+                  .where("data->>'email' = ?", email)
+                  .exists?
+      end
+
+      def skip_entry(entry, reason)
+        import.increment_skipped!
+        import.log_error("Skipped entry #{entry.id}: #{reason}")
+      end
+
+      def skip_duplicate(entry)
+        import.increment_skipped!
+        import.log_error("Duplicate email: #{entry_email(entry)}")
+      end
+
+      def create_item(entry)
+        Aven::Item.create!(
+          workspace_id: import.workspace_id,
+          schema_slug: target_schema,
+          data: build_item_data(entry)
+        )
+      end
+
+      def target_schema
+        case import.source
+        when "google_contacts", "gmail_emails"
+          "contact"
+        else
+          raise "Unknown source: #{import.source}"
+        end
+      end
+
+      def build_item_data(entry)
+        case import.source
+        when "google_contacts"
+          build_google_contact_data(entry.data)
+        when "gmail_emails"
+          build_gmail_email_data(entry.data)
+        else
+          entry.data
+        end
+      end
+
+      def build_google_contact_data(data)
+        {
+          "first_name" => data["first_name"].presence || "Unknown",
+          "last_name" => data["last_name"],
+          "email" => data["email"],
+          "phone" => data["phone"]
+        }.compact
+      end
+
+      def build_gmail_email_data(data)
+        first_name, last_name = parse_name(data["name"], data["email"])
+
+        {
+          "first_name" => first_name,
+          "last_name" => last_name,
+          "email" => data["email"]
+        }.compact
+      end
+
+      def parse_name(name, email)
+        if name.present?
+          parts = name.split(/\s+/, 2)
+          [parts[0], parts[1] || "Contact"]
+        else
+          local = email.to_s.split("@").first.to_s
+          parts = local.split(/[._-]/)
+          if parts.length >= 2
+            [parts[0].titleize, parts[1..].join(" ").titleize]
+          else
+            [local.titleize, "Contact"]
+          end
+        end
+      end
+  end
+end

data/app/models/aven/import.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_imports
+#
+#  id              :bigint           not null, primary key
+#  completed_at    :datetime
+#  error_message   :text
+#  errors_log      :jsonb
+#  imported_count  :integer          default(0)
+#  processed_count :integer          default(0)
+#  skipped_count   :integer          default(0)
+#  source          :string           not null
+#  started_at      :datetime
+#  status          :string           default("pending"), not null
+#  total_count     :integer          default(0)
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#  workspace_id    :bigint           not null
+#
+# Indexes
+#
+#  index_aven_imports_on_source        (source)
+#  index_aven_imports_on_status        (status)
+#  index_aven_imports_on_workspace_id  (workspace_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  class Import < ApplicationRecord
+    include Aven::Model::TenantModel
+
+    self.table_name = "aven_imports"
+
+    SOURCES = %w[google_contacts gmail_emails].freeze
+    STATUSES = %w[pending fetching processing completed failed].freeze
+
+    has_many :entries, class_name: "Aven::Import::Entry", dependent: :destroy
+
+    validates :source, presence: true, inclusion: { in: SOURCES }
+    validates :status, presence: true, inclusion: { in: STATUSES }
+
+    scope :in_progress, -> { where(status: %w[pending fetching processing]) }
+    scope :recent, -> { order(created_at: :desc) }
+    scope :by_source, ->(source) { where(source:) }
+
+    def in_progress?
+      %w[pending fetching processing].include?(status)
+    end
+
+    def completed?
+      status == "completed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def progress_percentage
+      return 0 if total_count.zero?
+      (processed_count * 100.0 / total_count).round
+    end
+
+    def mark_fetching!(total: nil)
+      attrs = { status: "fetching", started_at: Time.current }
+      attrs[:total_count] = total if total
+      update!(attrs)
+    end
+
+    def mark_processing!
+      update!(status: "processing")
+    end
+
+    def increment_processed!
+      increment!(:processed_count)
+    end
+
+    def increment_imported!
+      increment!(:imported_count)
+    end
+
+    def increment_skipped!
+      increment!(:skipped_count)
+    end
+
+    def mark_completed!
+      update!(status: "completed", completed_at: Time.current)
+    end
+
+    def mark_failed!(message)
+      update!(status: "failed", error_message: message, completed_at: Time.current)
+    end
+
+    def log_error(error)
+      self.errors_log = (errors_log || []) << { at: Time.current.iso8601, message: error }
+      save!
+    end
+  end
+end

data/app/models/aven/item/embed.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Aven
+  class Item::Embed
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attr_accessor :id, :_destroy
+
+    def initialize(attrs = {})
+      @attributes = (attrs || {}).with_indifferent_access
+      @id = @attributes["id"]
+    end
+
+    def [](key)
+      @attributes[key]
+    end
+
+    def []=(key, value)
+      @attributes[key] = value
+    end
+
+    def to_h
+      @attributes.to_h
+    end
+
+    alias_method :to_hash, :to_h
+
+    def persisted?
+      id.present?
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    def marked_for_destruction?
+      _destroy == "1" || _destroy == true
+    end
+
+    def method_missing(method, *args)
+      key = method.to_s
+      if key.end_with?("=")
+        @attributes[key.chomp("=")] = args.first
+      else
+        @attributes[key]
+      end
+    end
+
+    def respond_to_missing?(_method, _include_private = false)
+      true
+    end
+  end
+end

data/app/models/aven/item/embeddable.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Aven
+  module Item::Embeddable
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :assign_embed_ids
+    end
+
+    private
+
+      def assign_embed_ids
+        return if data.nil?
+        return if schema_slug.blank?
+
+        # Guard against schema not found - let validation handle the error
+        embeds = begin
+          schema_embeds
+        rescue ActiveRecord::RecordNotFound
+          {}
+        end
+
+        return if embeds.blank?
+
+        embeds.each do |name, config|
+          if config[:cardinality] == :many
+            assign_many_embed_ids(name)
+          else
+            assign_one_embed_id(name)
+          end
+        end
+      end
+
+      def assign_many_embed_ids(name)
+        embeds = data[name.to_s]
+        return if embeds.blank?
+
+        embeds.each do |embed|
+          embed["id"] ||= SecureRandom.uuid
+        end
+      end
+
+      def assign_one_embed_id(name)
+        embed = data[name.to_s]
+        return if embed.blank?
+
+        embed["id"] ||= SecureRandom.uuid
+      end
+
+      def process_embed_attributes(name, attrs)
+        config = schema_embeds[name]
+        return unless config
+
+        # Clear cache
+        cache_key = "@_embed_cache_#{name}"
+        remove_instance_variable(cache_key) if instance_variable_defined?(cache_key)
+
+        if config[:cardinality] == :many
+          process_many_embed_attributes(name, attrs)
+        else
+          process_one_embed_attributes(name, attrs)
+        end
+      end
+
+      def process_many_embed_attributes(name, attrs)
+        normalized = normalize_attrs(attrs)
+        existing = (data[name.to_s] || []).dup
+
+        normalized.each do |attr_hash|
+          if destroy_flag?(attr_hash)
+            # Remove by id if present
+            existing.reject! { |e| e["id"] == attr_hash["id"] } if attr_hash["id"]
+          elsif attr_hash["id"].present?
+            # Update existing
+            idx = existing.index { |e| e["id"] == attr_hash["id"] }
+            if idx
+              existing[idx] = existing[idx].merge(clean_attrs(attr_hash))
+            else
+              existing << clean_attrs(attr_hash.merge("id" => SecureRandom.uuid))
+            end
+          else
+            # New embed
+            existing << clean_attrs(attr_hash.merge("id" => SecureRandom.uuid))
+          end
+        end
+
+        data[name.to_s] = existing
+      end
+
+      def process_one_embed_attributes(name, attrs)
+        attr_hash = single_attrs(attrs)
+
+        if destroy_flag?(attr_hash)
+          data[name.to_s] = nil
+        elsif data[name.to_s].present?
+          data[name.to_s] = data[name.to_s].merge(clean_attrs(attr_hash))
+        else
+          data[name.to_s] = clean_attrs(attr_hash.merge("id" => SecureRandom.uuid))
+        end
+      end
+
+      def normalize_attrs(attrs)
+        case attrs
+        when Array
+          attrs.map(&:with_indifferent_access)
+        when Hash
+          # Could be indexed hash like {"0" => {...}, "1" => {...}}
+          if attrs.keys.all? { |k| k.to_s =~ /\A\d+\z/ }
+            attrs.values.map(&:with_indifferent_access)
+          else
+            [attrs.with_indifferent_access]
+          end
+        else
+          []
+        end
+      end
+
+      def single_attrs(attrs)
+        case attrs
+        when Hash
+          if attrs.keys.all? { |k| k.to_s =~ /\A\d+\z/ }
+            attrs.values.first&.with_indifferent_access || {}.with_indifferent_access
+          else
+            attrs.with_indifferent_access
+          end
+        else
+          {}.with_indifferent_access
+        end
+      end
+
+      def clean_attrs(hash)
+        hash.except(:_destroy, "_destroy").transform_keys(&:to_s)
+      end
+
+      def destroy_flag?(attrs)
+        val = attrs[:_destroy] || attrs["_destroy"]
+        val == "1" || val == true
+      end
+  end
+end