aven 0.0.3

data/app/models/aven/item.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_items
+#
+#  id           :bigint           not null, primary key
+#  data         :jsonb            not null
+#  deleted_at   :datetime
+#  schema_slug  :string           not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  workspace_id :bigint           not null
+#
+# Indexes
+#
+#  index_aven_items_on_data          (data) USING gin
+#  index_aven_items_on_deleted_at    (deleted_at)
+#  index_aven_items_on_schema_slug   (schema_slug)
+#  index_aven_items_on_workspace_id  (workspace_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  class Item < ApplicationRecord
+    include Aven::Model::TenantModel
+    include Aven::Loggable
+    include Item::Schemaed
+    include Item::Embeddable
+    include Item::Linkable
+
+    self.table_name = "aven_items"
+
+    validates :schema_slug, presence: true
+    validates :data, presence: true
+    validate :validate_data_against_schema
+
+    scope :active, -> { where(deleted_at: nil) }
+    scope :deleted, -> { where.not(deleted_at: nil) }
+    scope :by_schema, ->(slug) { where(schema_slug: slug) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def soft_delete!
+      update!(deleted_at: Time.current)
+    end
+
+    def restore!
+      update!(deleted_at: nil)
+    end
+
+    def deleted?
+      deleted_at.present?
+    end
+
+    # Schema resolution: code class first, then DB, then raise
+    class << self
+      def schema_class_for(slug)
+        "Aven::Item::Schemas::#{slug.to_s.camelize}".constantize
+      rescue NameError
+        nil
+      end
+
+      def schema_for(slug, workspace: nil)
+        # 1. Try code-defined class
+        schema_class_for(slug) ||
+        # 2. Try DB (requires workspace)
+        (workspace && Aven::ItemSchema.find_by!(workspace:, slug:))
+      end
+    end
+
+    def schema_class
+      self.class.schema_class_for(schema_slug)
+    end
+
+    # Returns the schema source (code class or DB record)
+    def resolved_schema
+      @_resolved_schema ||= begin
+        # 1. Code class first
+        code_schema = self.class.schema_class_for(schema_slug)
+        return code_schema if code_schema
+
+        # 2. DB lookup (raises if not found)
+        Aven::ItemSchema.find_by!(workspace:, slug: schema_slug)
+      end
+    end
+
+    def schema_builder
+      resolved_schema&.builder
+    end
+
+    private
+
+      def validate_data_against_schema
+        return if schema_slug.blank? || data.blank?
+
+        begin
+          json_schema = resolved_schema&.to_json_schema
+          return if json_schema.blank?
+
+          registry = JSONSkooma.create_registry("2020-12", assert_formats: true)
+          schema_with_meta = json_schema.dup
+          schema_with_meta["$schema"] ||= "https://json-schema.org/draft/2020-12/schema"
+          validator = JSONSkooma::JSONSchema.new(schema_with_meta, registry:)
+          result = validator.evaluate(data)
+
+          unless result.valid?
+            error_output = result.output(:basic)
+            if error_output["errors"]
+              error_messages = error_output["errors"].map do |err|
+                location = err["instanceLocation"] || "data"
+                message = err["error"] || "validation failed"
+                "#{location}: #{message}"
+              end
+              errors.add(:data, "schema validation failed: #{error_messages.join('; ')}")
+            else
+              errors.add(:data, "does not conform to schema")
+            end
+          end
+        rescue ActiveRecord::RecordNotFound
+          errors.add(:schema_slug, "schema '#{schema_slug}' not found")
+        rescue => e
+          errors.add(:data, "schema validation error: #{e.message}")
+        end
+      end
+  end
+end

data/app/models/aven/item_link.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_item_links
+#
+#  id         :bigint           not null, primary key
+#  position   :integer          default(0)
+#  relation   :string           not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#  source_id  :bigint           not null
+#  target_id  :bigint           not null
+#
+# Indexes
+#
+#  index_aven_item_links_on_source_id                             (source_id)
+#  index_aven_item_links_on_source_id_and_relation                (source_id,relation)
+#  index_aven_item_links_on_source_id_and_target_id_and_relation  (source_id,target_id,relation) UNIQUE
+#  index_aven_item_links_on_target_id                             (target_id)
+#  index_aven_item_links_on_target_id_and_relation                (target_id,relation)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (source_id => aven_items.id)
+#  fk_rails_...  (target_id => aven_items.id)
+#
+module Aven
+  class ItemLink < ApplicationRecord
+    self.table_name = "aven_item_links"
+
+    belongs_to :source, class_name: "Aven::Item"
+    belongs_to :target, class_name: "Aven::Item"
+
+    validates :relation, presence: true
+    validates :target_id, uniqueness: { scope: [:source_id, :relation] }
+
+    scope :for_relation, ->(rel) { where(relation: rel.to_s) }
+    scope :ordered, -> { order(position: :asc) }
+
+    delegate :workspace, :workspace_id, to: :source
+  end
+end

data/app/models/aven/item_schema.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_item_schemas
+#
+#  id           :bigint           not null, primary key
+#  embeds       :jsonb            not null
+#  fields       :jsonb            not null
+#  links        :jsonb            not null
+#  schema       :jsonb            not null
+#  slug         :string           not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  workspace_id :bigint           not null
+#
+# Indexes
+#
+#  index_aven_item_schemas_on_slug                   (slug)
+#  index_aven_item_schemas_on_workspace_id           (workspace_id)
+#  index_aven_item_schemas_on_workspace_id_and_slug  (workspace_id,slug) UNIQUE
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  class ItemSchema < ApplicationRecord
+    self.table_name = "aven_item_schemas"
+
+    include Aven::Model::TenantModel
+    include Aven::Loggable
+
+    has_many :items, ->(schema) { where(schema_slug: schema.slug) },
+             class_name: "Aven::Item",
+             foreign_key: false,
+             inverse_of: false
+
+    validates :slug, presence: true,
+                     uniqueness: { scope: :workspace_id },
+                     format: { with: /\A[a-z][a-z0-9_]*\z/, message: "must be lowercase, start with letter, contain only letters/numbers/underscores" }
+    validates :schema, presence: true
+    validate :validate_schema_format
+
+    # Mimic the interface of code-defined schemas (Item::Schemas::Base)
+    def builder
+      self
+    end
+
+    def to_json_schema
+      schema
+    end
+
+    # Accessors that match Item::Schemas::Base interface
+    def fields_config
+      (fields || {}).deep_symbolize_keys
+    end
+
+    def embeds_config
+      (embeds || {}).deep_symbolize_keys
+    end
+
+    def links_config
+      (links || {}).deep_symbolize_keys
+    end
+
+    # Alias methods to match Schemas::Base
+    alias_method :schema_fields, :fields_config
+    alias_method :schema_embeds, :embeds_config
+    alias_method :schema_links, :links_config
+
+    private
+
+      def validate_schema_format
+        return if schema.blank?
+
+        unless schema.is_a?(Hash)
+          errors.add(:schema, "must be a valid JSON object")
+          return
+        end
+
+        unless schema["type"].present?
+          errors.add(:schema, "must include a 'type' property")
+        end
+      end
+  end
+end

data/app/models/aven/log.rb

@@ -0,0 +1,66 @@
+# == Schema Information
+#
+# Table name: aven_logs
+#
+#  id            :bigint           not null, primary key
+#  level         :string           default("info"), not null
+#  loggable_type :string           not null
+#  message       :text             not null
+#  metadata      :jsonb
+#  state         :string
+#  state_machine :string
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#  loggable_id   :bigint           not null
+#  run_id        :string
+#  workspace_id  :bigint           not null
+#
+# Indexes
+#
+#  idx_aven_logs_on_loggable_run_state_created_at  (loggable_type,loggable_id,run_id,state,created_at)
+#  index_aven_logs_on_created_at                   (created_at)
+#  index_aven_logs_on_level                        (level)
+#  index_aven_logs_on_loggable                     (loggable_type,loggable_id)
+#  index_aven_logs_on_workspace_id                 (workspace_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  class Log < ApplicationRecord
+    self.table_name = "aven_logs"
+
+    LEVELS = %w[debug info warn error fatal].freeze
+
+    belongs_to :loggable, polymorphic: true
+    belongs_to :workspace, class_name: "Aven::Workspace"
+
+    validates :message, presence: true
+    validates :level, inclusion: { in: LEVELS }
+
+    scope :by_level, ->(level) { where(level:) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    before_validation :apply_loggable_context
+
+    private
+
+      def apply_loggable_context
+        owner = loggable
+        return unless owner
+
+        if respond_to?(:workspace_id) && workspace_id.blank?
+          if owner.is_a?(Aven::Workspace)
+            self.workspace = owner
+          elsif owner.respond_to?(:workspace)
+            self.workspace = owner.workspace
+          end
+        end
+
+        if respond_to?(:run_id) && run_id.blank? && owner.respond_to?(:_log_run_id)
+          self.run_id = owner._log_run_id
+        end
+      end
+  end
+end

data/app/models/aven/loggable.rb

@@ -0,0 +1,20 @@
+module Aven
+  module Loggable
+    def log!(message:, level: "info", metadata: nil, **extra)
+      attrs = {
+        message:,
+        level:,
+        metadata: metadata || {}
+      }
+
+      ws = is_a?(Aven::Workspace) ? self : workspace
+      attrs[:workspace] = ws
+
+      attrs[:run_id] = extra[:run_id] if extra.key?(:run_id)
+      attrs[:state] = extra[:state] if extra.key?(:state)
+      attrs[:state_machine] = extra[:state_machine] if extra.key?(:state_machine)
+
+      logs.create!(attrs)
+    end
+  end
+end

data/app/models/aven/user.rb

@@ -0,0 +1,40 @@
+# == Schema Information
+#
+# Table name: aven_users
+#
+#  id                     :bigint           not null, primary key
+#  access_token           :string
+#  admin                  :boolean          default(FALSE), not null
+#  auth_tenant            :string
+#  email                  :string           default(""), not null
+#  encrypted_password     :string           default(""), not null
+#  remember_created_at    :datetime
+#  reset_password_sent_at :datetime
+#  reset_password_token   :string
+#  created_at             :datetime         not null
+#  updated_at             :datetime         not null
+#  remote_id              :string
+#
+# Indexes
+#
+#  index_aven_users_on_email_and_auth_tenant  (email,auth_tenant) UNIQUE
+#  index_aven_users_on_reset_password_token   (reset_password_token) UNIQUE
+#
+module Aven
+  class User < ApplicationRecord
+    has_many :workspace_users, dependent: :destroy
+    has_many :workspaces, through: :workspace_users
+    has_many :workspace_user_roles, through: :workspace_users
+    has_many :workspace_roles, through: :workspace_user_roles
+
+    # has_many(:repos, class_name: UserRepo.name)
+    # has_many(:deployments)
+    # has_many(:strategies, foreign_key: :author_id, inverse_of: :author)
+    # has_many(:credentials, class_name: ProviderCredential.name)
+
+    validates :email, presence: true, uniqueness: { scope: :auth_tenant, case_sensitive: false }, format: { with: URI::MailTo::EMAIL_REGEXP }
+    validates :remote_id, uniqueness: { scope: :auth_tenant, case_sensitive: false }, allow_blank: true
+
+    encrypts(:access_token)
+  end
+end

data/app/models/aven/workspace.rb

@@ -0,0 +1,93 @@
+# == Schema Information
+#
+# Table name: aven_workspaces
+#
+#  id          :bigint           not null, primary key
+#  description :text
+#  domain      :string
+#  label       :string
+#  slug        :string
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#
+# Indexes
+#
+#  index_aven_workspaces_on_slug  (slug) UNIQUE
+#
+module Aven
+  class Workspace < ApplicationRecord
+    extend FriendlyId
+    friendly_id :label, use: :slugged
+
+    self.table_name = "aven_workspaces"
+
+    has_many :workspace_users, class_name: "Aven::WorkspaceUser", dependent: :destroy
+    has_many :users, through: :workspace_users, class_name: "Aven::User"
+    has_many :workspace_roles, class_name: "Aven::WorkspaceRole", dependent: :destroy
+    has_many :workspace_user_roles, through: :workspace_roles, class_name: "Aven::WorkspaceUserRole"
+
+    # Agentic associations
+    has_many :aven_agentic_agents, class_name: "Aven::Agentic::Agent", dependent: :destroy
+    has_many :aven_agentic_documents, class_name: "Aven::Agentic::Document", dependent: :destroy
+
+    # Chat associations
+    has_many :aven_chat_threads, class_name: "Aven::Chat::Thread", dependent: :destroy
+
+    # Article associations
+    has_many :aven_articles, class_name: "Aven::Article", dependent: :destroy
+
+    validates :slug, uniqueness: true, allow_blank: true
+    validates :label, length: { maximum: 255 }, allow_blank: true
+    validates :description, length: { maximum: 1000 }, allow_blank: true
+
+    # Tenant model registry (inspired by Flipper's group registry pattern)
+    class << self
+      # Returns array of all registered tenant model classes
+      def tenant_models
+        @tenant_models ||= []
+      end
+
+      # Register a model class as workspace-scoped
+      # Called automatically when a model includes Aven::TenantModel
+      def register_tenant_model(model_class)
+        return if tenant_models.include?(model_class)
+
+        tenant_models << model_class
+        define_tenant_association(model_class)
+      end
+
+      # Get all registered tenant model class names
+      def tenant_model_names
+        tenant_models.map(&:name)
+      end
+
+      private
+
+        # Define association method for a tenant model
+        # Creates query method that returns ActiveRecord::Relation
+        def define_tenant_association(model_class)
+          association_name = model_class.workspace_association_name
+
+          # Define instance method for querying tenant records
+          define_method(association_name) do
+            model_class.where(workspace_id: id)
+          end
+        end
+    end
+
+    # Find a tenant record by type and ID
+    def find_tenant_record(model_name, record_id)
+      model_class = self.class.tenant_models.find { |m| m.name == model_name }
+      return nil unless model_class
+
+      model_class.where(workspace_id: id).find(record_id)
+    end
+
+    # Destroy all tenant data for this workspace
+    def destroy_tenant_data
+      self.class.tenant_models.each do |model_class|
+        model_class.where(workspace_id: id).destroy_all
+      end
+    end
+  end
+end

data/app/models/aven/workspace_role.rb

@@ -0,0 +1,46 @@
+# == Schema Information
+#
+# Table name: aven_workspace_roles
+#
+#  id           :bigint           not null, primary key
+#  description  :string
+#  label        :string           not null
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  workspace_id :bigint
+#
+# Indexes
+#
+#  idx_aven_workspace_roles_on_ws_label        (workspace_id,label) UNIQUE
+#  index_aven_workspace_roles_on_workspace_id  (workspace_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  class WorkspaceRole < ApplicationRecord
+    self.table_name = "aven_workspace_roles"
+
+    belongs_to :workspace, class_name: "Aven::Workspace"
+    has_many :workspace_user_roles, class_name: "Aven::WorkspaceUserRole", dependent: :destroy
+    has_many :workspace_users, through: :workspace_user_roles, class_name: "Aven::WorkspaceUser"
+    has_many :users, through: :workspace_users, class_name: "Aven::User"
+
+    validates :label, presence: true
+    validates :label, uniqueness: { scope: :workspace_id }
+
+    PREDEFINED_ROLES = %w[owner admin member viewer].freeze
+
+    scope :predefined, -> { where(label: PREDEFINED_ROLES) }
+    scope :custom, -> { where.not(label: PREDEFINED_ROLES) }
+
+    def predefined?
+      PREDEFINED_ROLES.include?(label)
+    end
+
+    def custom?
+      !predefined?
+    end
+  end
+end

data/app/models/aven/workspace_user.rb

@@ -0,0 +1,54 @@
+# == Schema Information
+#
+# Table name: aven_workspace_users
+#
+#  id           :bigint           not null, primary key
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#  user_id      :bigint           not null
+#  workspace_id :bigint           not null
+#
+# Indexes
+#
+#  idx_aven_workspace_users_on_user_workspace  (user_id,workspace_id) UNIQUE
+#  index_aven_workspace_users_on_user_id       (user_id)
+#  index_aven_workspace_users_on_workspace_id  (workspace_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (user_id => aven_users.id)
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  class WorkspaceUser < ApplicationRecord
+    self.table_name = "aven_workspace_users"
+
+    belongs_to :user, class_name: "Aven::User"
+    belongs_to :workspace, class_name: "Aven::Workspace"
+
+    has_many :workspace_user_roles, class_name: "Aven::WorkspaceUserRole", dependent: :destroy
+    has_many :workspace_roles, through: :workspace_user_roles, class_name: "Aven::WorkspaceRole"
+
+    validates :user_id, uniqueness: { scope: :workspace_id }
+
+    def roles
+      workspace_roles.pluck(:label)
+    end
+
+    def has_role?(role_label)
+      workspace_roles.exists?(label: role_label)
+    end
+
+    def add_role(role_label)
+      role = workspace.workspace_roles.find_or_create_by!(label: role_label)
+      workspace_user_roles.find_or_create_by!(workspace_role: role)
+    end
+
+    def remove_role(role_label)
+      role = workspace.workspace_roles.find_by(label: role_label)
+      return unless role
+
+      workspace_user_roles.where(workspace_role: role).destroy_all
+    end
+  end
+end

data/app/models/aven/workspace_user_role.rb

@@ -0,0 +1,38 @@
+# == Schema Information
+#
+# Table name: aven_workspace_user_roles
+#
+#  id                :bigint           not null, primary key
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#  workspace_role_id :bigint
+#  workspace_user_id :bigint
+#
+# Indexes
+#
+#  idx_aven_ws_user_roles_on_role_user                   (workspace_role_id,workspace_user_id) UNIQUE
+#  index_aven_workspace_user_roles_on_workspace_role_id  (workspace_role_id)
+#  index_aven_workspace_user_roles_on_workspace_user_id  (workspace_user_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_role_id => aven_workspace_roles.id)
+#  fk_rails_...  (workspace_user_id => aven_workspace_users.id)
+#
+module Aven
+  class WorkspaceUserRole < ApplicationRecord
+    self.table_name = "aven_workspace_user_roles"
+
+    belongs_to :workspace_user, class_name: "Aven::WorkspaceUser"
+    belongs_to :workspace_role, class_name: "Aven::WorkspaceRole"
+
+    validates :workspace_user_id, uniqueness: { scope: :workspace_role_id }
+
+    delegate :workspace, :label, :description, to: :workspace_role
+    delegate :user, to: :workspace_user
+    delegate :email, :username, to: :user
+
+    scope :for_workspace, ->(workspace) { joins(:workspace_role).where(aven_workspace_roles: { workspace_id: workspace.id }) }
+    scope :with_role, ->(role_label) { joins(:workspace_role).where(aven_workspace_roles: { label: role_label }) }
+  end
+end

data/app/models/concerns/aven/agentic/document_embeddable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module DocumentEmbeddable
+      extend ActiveSupport::Concern
+
+      included do
+        # Override in subclasses to customize embedding behavior
+      end
+
+      # Split content into chunks for embedding
+      def chunk_content(content, chunk_size: 1000, overlap: 200)
+        return [] if content.blank?
+
+        chunks = []
+        position = 0
+
+        while position < content.length
+          chunk_end = [position + chunk_size, content.length].min
+          chunks << content[position...chunk_end]
+          position += (chunk_size - overlap)
+        end
+
+        chunks
+      end
+
+      # Generate embeddings for all chunks
+      def generate_embeddings!
+        return unless ocr_content.present?
+
+        chunks = chunk_content(ocr_content)
+
+        transaction do
+          embeddings.destroy_all
+
+          chunks.each_with_index do |chunk, index|
+            embeddings.create!(
+              chunk_index: index,
+              content: chunk,
+              embedding: nil # Will be filled by embedding service
+            )
+          end
+        end
+      end
+
+      # Search similar chunks using vector similarity
+      def self.search_similar(query_embedding, workspace:, limit: 10)
+        Aven::Agentic::DocumentEmbedding
+          .joins(:document)
+          .where(aven_agentic_documents: { workspace_id: workspace.id })
+          .where.not(embedding: nil)
+          .order(Arel.sql("embedding <-> '#{query_embedding}'"))
+          .limit(limit)
+      end
+    end
+  end
+end