aven 0.0.3

data/app/models/aven/agentic/document.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_documents
+#
+#  id               :bigint           not null, primary key
+#  byte_size        :bigint           not null
+#  content_type     :string           not null
+#  embedding_status :string           default("pending"), not null
+#  filename         :string           not null
+#  metadata         :jsonb
+#  ocr_content      :text
+#  ocr_status       :string           default("pending"), not null
+#  processed_at     :datetime
+#  created_at       :datetime         not null
+#  updated_at       :datetime         not null
+#  workspace_id     :bigint           not null
+#
+# Indexes
+#
+#  index_aven_agentic_documents_on_content_type      (content_type)
+#  index_aven_agentic_documents_on_embedding_status  (embedding_status)
+#  index_aven_agentic_documents_on_ocr_status        (ocr_status)
+#  index_aven_agentic_documents_on_workspace_id      (workspace_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  module Agentic
+    class Document < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_documents"
+
+      include Aven::Model::TenantModel
+      include Aven::Agentic::DocumentEmbeddable
+
+      has_one_attached :file
+
+      has_many :embeddings,
+               class_name: "Aven::Agentic::DocumentEmbedding",
+               foreign_key: :document_id,
+               dependent: :destroy
+
+      has_many :agent_documents,
+               class_name: "Aven::Agentic::AgentDocument",
+               foreign_key: :document_id,
+               dependent: :destroy,
+               inverse_of: :document
+
+      has_many :agents, through: :agent_documents
+
+      # Statuses
+      OCR_STATUSES = %w[pending processing completed failed skipped].freeze
+      EMBEDDING_STATUSES = %w[pending processing completed failed].freeze
+
+      # Allowed file types
+      ALLOWED_CONTENT_TYPES = [
+        "application/pdf",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "image/jpeg",
+        "image/png",
+        "image/gif",
+        "image/webp"
+      ].freeze
+
+      MAX_FILE_SIZE = 30.megabytes
+
+      validates :filename, presence: true
+      validates :content_type, presence: true, inclusion: { in: ALLOWED_CONTENT_TYPES }
+      validates :byte_size, presence: true, numericality: { less_than_or_equal_to: MAX_FILE_SIZE }
+      validates :ocr_status, inclusion: { in: OCR_STATUSES }
+      validates :embedding_status, inclusion: { in: EMBEDDING_STATUSES }
+      validate :file_attached
+
+      after_create_commit :enqueue_ocr_job
+
+      scope :recent, -> { order(created_at: :desc) }
+      scope :by_type, ->(type) { where("content_type LIKE ?", "#{type}%") }
+      scope :images, -> { where("content_type LIKE ?", "image/%") }
+      scope :pdfs, -> { where(content_type: "application/pdf") }
+      scope :with_ocr, -> { where(ocr_status: "completed").where.not(ocr_content: nil) }
+      scope :pending_ocr, -> { where(ocr_status: "pending") }
+      scope :pending_embedding, -> { where(embedding_status: "pending", ocr_status: "completed") }
+
+      def image?
+        content_type.start_with?("image/")
+      end
+
+      def pdf?
+        content_type == "application/pdf"
+      end
+
+      def word_doc?
+        content_type.include?("wordprocessingml")
+      end
+
+      def excel?
+        content_type.include?("spreadsheetml")
+      end
+
+      def ocr_required?
+        image? || pdf?
+      end
+
+      def mark_ocr_processing!
+        update!(ocr_status: "processing")
+      end
+
+      def mark_ocr_completed!(content)
+        update!(
+          ocr_status: "completed",
+          ocr_content: content,
+          processed_at: Time.current
+        )
+        enqueue_embedding_job if content.present?
+      end
+
+      def mark_ocr_failed!(error = nil)
+        update!(
+          ocr_status: "failed",
+          metadata: metadata.merge("ocr_error" => error)
+        )
+      end
+
+      def mark_ocr_skipped!
+        update!(ocr_status: "skipped")
+      end
+
+      def mark_embedding_processing!
+        update!(embedding_status: "processing")
+      end
+
+      def mark_embedding_completed!
+        update!(embedding_status: "completed")
+      end
+
+      def mark_embedding_failed!(error = nil)
+        update!(
+          embedding_status: "failed",
+          metadata: metadata.merge("embedding_error" => error)
+        )
+      end
+
+      private
+
+        def file_attached
+          errors.add(:file, "must be attached") unless file.attached?
+        end
+
+        def enqueue_ocr_job
+          Aven::Agentic::DocumentOcrJob.perform_later(id) if ocr_required?
+        end
+
+        def enqueue_embedding_job
+          Aven::Agentic::DocumentEmbeddingJob.perform_later(id)
+        end
+    end
+  end
+end

data/app/models/aven/agentic/document_embedding.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_document_embeddings
+#
+#  id          :bigint           not null, primary key
+#  chunk_index :integer          not null
+#  content     :text             not null
+#  embedding   :vector(1536)
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  document_id :bigint           not null
+#
+# Indexes
+#
+#  idx_on_document_id_chunk_index_5fe199c056              (document_id,chunk_index) UNIQUE
+#  index_aven_agentic_document_embeddings_on_document_id  (document_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (document_id => aven_agentic_documents.id)
+#
+module Aven
+  module Agentic
+    class DocumentEmbedding < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_document_embeddings"
+
+      belongs_to :document, class_name: "Aven::Agentic::Document"
+
+      validates :chunk_index, presence: true, uniqueness: { scope: :document_id }
+      validates :content, presence: true
+
+      scope :ordered, -> { order(:chunk_index) }
+
+      delegate :workspace, :workspace_id, to: :document
+    end
+  end
+end

data/app/models/aven/agentic/tool.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_tools
+#
+#  id                  :bigint           not null, primary key
+#  class_name          :string           not null
+#  default_description :text
+#  description         :text
+#  enabled             :boolean          default(TRUE), not null
+#  name                :string           not null
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#  workspace_id        :bigint
+#
+# Indexes
+#
+#  index_aven_agentic_tools_on_enabled                      (enabled)
+#  index_aven_agentic_tools_on_workspace_id                 (workspace_id)
+#  index_aven_agentic_tools_on_workspace_id_and_class_name  (workspace_id,class_name) UNIQUE
+#  index_aven_agentic_tools_on_workspace_id_and_name        (workspace_id,name) UNIQUE
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  module Agentic
+    class Tool < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_tools"
+
+      belongs_to :workspace, class_name: "Aven::Workspace", optional: true
+
+      has_many :parameters,
+               class_name: "Aven::Agentic::ToolParameter",
+               foreign_key: :tool_id,
+               dependent: :destroy,
+               inverse_of: :tool
+
+      has_many :agent_tools,
+               class_name: "Aven::Agentic::AgentTool",
+               foreign_key: :tool_id,
+               dependent: :destroy,
+               inverse_of: :tool
+
+      has_many :agents, through: :agent_tools
+
+      accepts_nested_attributes_for :parameters, allow_destroy: true
+
+      validates :name, presence: true, uniqueness: { scope: :workspace_id }
+      validates :class_name, presence: true, uniqueness: { scope: :workspace_id }
+
+      scope :enabled, -> { where(enabled: true) }
+      scope :global, -> { where(workspace_id: nil) }
+      scope :for_workspace, ->(workspace) {
+        where(workspace_id: [nil, workspace.id])
+      }
+
+      # Get the actual tool class
+      def tool_class
+        class_name.constantize
+      rescue NameError
+        nil
+      end
+
+      # Check if tool class exists and is valid
+      def valid_class?
+        klass = tool_class
+        klass.present? && klass < Aven::Agentic::Tools::Base
+      end
+
+      # Get effective description (user-enriched or default)
+      def effective_description
+        description.presence || default_description
+      end
+
+      # Sync from code definition
+      def sync_from_code!
+        klass = tool_class
+        return false unless klass
+
+        self.default_description = klass.default_description
+
+        code_params = klass.parameters
+        code_names = code_params.map { |p| p.name.to_s }
+
+        # Remove deleted parameters
+        parameters.where.not(name: code_names).destroy_all
+
+        # Create or update parameters
+        code_params.each_with_index do |param_def, index|
+          param = parameters.find_or_initialize_by(name: param_def.name.to_s)
+          param.param_type = param_def.type.to_s
+          param.default_description = param_def.description
+          param.required = param_def.required || false
+          param.constraints = param_def.constraints || {}
+          param.position = index
+          param.save!
+        end
+
+        save!
+      end
+    end
+  end
+end

data/app/models/aven/agentic/tool_parameter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_tool_parameters
+#
+#  id                  :bigint           not null, primary key
+#  constraints         :jsonb
+#  default_description :text
+#  description         :text
+#  name                :string           not null
+#  param_type          :string           not null
+#  position            :integer          default(0), not null
+#  required            :boolean          default(FALSE), not null
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#  tool_id             :bigint           not null
+#
+# Indexes
+#
+#  index_aven_agentic_tool_parameters_on_tool_id               (tool_id)
+#  index_aven_agentic_tool_parameters_on_tool_id_and_name      (tool_id,name) UNIQUE
+#  index_aven_agentic_tool_parameters_on_tool_id_and_position  (tool_id,position)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (tool_id => aven_agentic_tools.id)
+#
+module Aven
+  module Agentic
+    class ToolParameter < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_tool_parameters"
+
+      belongs_to :tool, class_name: "Aven::Agentic::Tool", inverse_of: :parameters
+
+      validates :name, presence: true, uniqueness: { scope: :tool_id }
+      validates :param_type, presence: true
+
+      default_scope { order(:position) }
+
+      PARAM_TYPES = %w[string integer float boolean array object].freeze
+
+      validates :param_type, inclusion: { in: PARAM_TYPES }
+
+      # Get effective description (user-enriched or default)
+      def effective_description
+        description.presence || default_description
+      end
+
+      # Check if parameter is required
+      def required?
+        required
+      end
+    end
+  end
+end

data/app/models/aven/application_record.rb

@@ -0,0 +1,5 @@
+module Aven
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/aven/article.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Aven
+  class Article < ApplicationRecord
+    self.table_name = "aven_articles"
+
+    include Aven::Model::TenantModel
+
+    extend FriendlyId
+    friendly_id :title, use: [:slugged, :scoped], scope: :workspace
+
+    acts_as_taggable_on :tags
+
+    # Associations
+    belongs_to :author, class_name: "Aven::User", optional: true
+
+    has_one_attached :main_visual
+
+    has_many :article_attachments,
+             class_name: "Aven::ArticleAttachment",
+             foreign_key: :article_id,
+             dependent: :destroy,
+             inverse_of: :article
+
+    has_many :article_relationships,
+             -> { order(position: :asc) },
+             class_name: "Aven::ArticleRelationship",
+             foreign_key: :article_id,
+             dependent: :destroy,
+             inverse_of: :article
+
+    has_many :related_articles,
+             through: :article_relationships,
+             source: :related_article
+
+    has_many :inverse_article_relationships,
+             class_name: "Aven::ArticleRelationship",
+             foreign_key: :related_article_id,
+             dependent: :destroy
+
+    has_many :inverse_related_articles,
+             through: :inverse_article_relationships,
+             source: :article
+
+    # Nested attributes
+    accepts_nested_attributes_for :article_attachments, allow_destroy: true
+    accepts_nested_attributes_for :article_relationships, allow_destroy: true
+
+    # Validations
+    validates :title, presence: true
+    validates :slug, uniqueness: { scope: :workspace_id }, allow_blank: true
+
+    # Scopes
+    scope :published, -> { where.not(published_at: nil).where("published_at <= ?", Time.current) }
+    scope :draft, -> { where(published_at: nil) }
+    scope :scheduled, -> { where.not(published_at: nil).where("published_at > ?", Time.current) }
+    scope :recent, -> { order(Arel.sql("published_at DESC NULLS LAST, created_at DESC")) }
+    scope :by_author, ->(user) { where(author: user) }
+
+    # Instance methods
+    def published?
+      published_at.present? && published_at <= Time.current
+    end
+
+    def draft?
+      published_at.nil?
+    end
+
+    def scheduled?
+      published_at.present? && published_at > Time.current
+    end
+
+    def publish!
+      update!(published_at: Time.current)
+    end
+
+    def unpublish!
+      update!(published_at: nil)
+    end
+
+    # Returns sorted attachments
+    def sorted_attachments
+      article_attachments.order(position: :asc)
+    end
+  end
+end

data/app/models/aven/article_attachment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Aven
+  class ArticleAttachment < ApplicationRecord
+    self.table_name = "aven_article_attachments"
+
+    belongs_to :article, class_name: "Aven::Article", inverse_of: :article_attachments
+
+    has_one_attached :file
+
+    validates :position, presence: true, numericality: { greater_than_or_equal_to: 0 }
+
+    scope :ordered, -> { order(position: :asc) }
+
+    # Delegate workspace access
+    delegate :workspace, :workspace_id, to: :article
+  end
+end

data/app/models/aven/article_relationship.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Aven
+  class ArticleRelationship < ApplicationRecord
+    self.table_name = "aven_article_relationships"
+
+    belongs_to :article, class_name: "Aven::Article", inverse_of: :article_relationships
+    belongs_to :related_article, class_name: "Aven::Article"
+
+    validates :related_article_id, uniqueness: { scope: :article_id }
+    validate :not_self_referential
+
+    scope :ordered, -> { order(position: :asc) }
+
+    # Delegate workspace access
+    delegate :workspace, :workspace_id, to: :article
+
+    private
+
+      def not_self_referential
+        if article_id == related_article_id
+          errors.add(:related_article, "cannot be the same as the article")
+        end
+      end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_chat_messages
+#
+#  id            :bigint           not null, primary key
+#  completed_at  :datetime
+#  content       :text
+#  cost_usd      :decimal(10, 6)   default(0.0)
+#  input_tokens  :integer          default(0)
+#  model         :string
+#  output_tokens :integer          default(0)
+#  role          :string           not null
+#  started_at    :datetime
+#  status        :string           default("pending")
+#  tool_call     :jsonb
+#  total_tokens  :integer          default(0)
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#  parent_id     :bigint
+#  thread_id     :bigint           not null
+#
+# Indexes
+#
+#  index_aven_chat_messages_on_parent_id                 (parent_id)
+#  index_aven_chat_messages_on_role                      (role)
+#  index_aven_chat_messages_on_status                    (status)
+#  index_aven_chat_messages_on_thread_id                 (thread_id)
+#  index_aven_chat_messages_on_thread_id_and_created_at  (thread_id,created_at)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (parent_id => aven_chat_messages.id)
+#  fk_rails_...  (thread_id => aven_chat_threads.id)
+#
+module Aven
+  module Chat
+    class Message < Aven::ApplicationRecord
+      self.table_name = "aven_chat_messages"
+
+      belongs_to :thread, class_name: "Aven::Chat::Thread"
+      belongs_to :parent, class_name: "Aven::Chat::Message", optional: true
+
+      has_many :replies,
+               class_name: "Aven::Chat::Message",
+               foreign_key: :parent_id,
+               dependent: :nullify
+
+      enum :role, {
+        user: "user",
+        assistant: "assistant",
+        tool: "tool",
+        system: "system"
+      }, prefix: true
+
+      enum :status, {
+        pending: "pending",
+        streaming: "streaming",
+        success: "success",
+        error: "error"
+      }, prefix: true, default: :pending
+
+      validates :thread, :role, presence: true
+      validates :content, presence: true, unless: -> { role_assistant? && (status_pending? || status_streaming?) }
+
+      scope :by_tool_call_id, ->(id) { where("tool_call->>'id' = ?", id) }
+      scope :chronological, -> { order(:created_at) }
+
+      after_create_commit :broadcast_created
+      after_update_commit :broadcast_updated
+
+      # Calculate duration if timing is available
+      def duration
+        return nil unless started_at && completed_at
+
+        completed_at - started_at
+      end
+
+      def mark_started!
+        update!(started_at: Time.current, status: :streaming)
+      end
+
+      def mark_completed!(content: nil, model: nil, tokens: {})
+        update!(
+          completed_at: Time.current,
+          status: :success,
+          content:,
+          model:,
+          input_tokens: tokens[:input] || 0,
+          output_tokens: tokens[:output] || 0,
+          total_tokens: tokens[:total] || 0
+        )
+      end
+
+      def mark_failed!(error_message)
+        update!(
+          completed_at: Time.current,
+          status: :error,
+          content: error_message
+        )
+      end
+
+      # Append content during streaming
+      def append_content!(chunk)
+        new_content = (content || "") + chunk
+        update_column(:content, new_content)
+        broadcast_streaming(new_content)
+      end
+
+      private
+
+        def broadcast_created
+          Aven::Chat::ThreadChannel.broadcast_to(thread, {
+            type: "message_created",
+            message: as_json
+          })
+        end
+
+        def broadcast_updated
+          Aven::Chat::ThreadChannel.broadcast_to(thread, {
+            type: "message_updated",
+            message: as_json
+          })
+        end
+
+        def broadcast_streaming(content)
+          Aven::Chat::ThreadChannel.broadcast_to(thread, {
+            type: "message_streaming",
+            message: { id:, content: }
+          })
+        end
+    end
+  end
+end