aven 0.0.3

data/app/services/aven/chat/title_generator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Aven
+  module Chat
+    class TitleGenerator
+      MAX_TITLE_LENGTH = 100
+
+      def initialize(thread, first_message)
+        @thread = thread
+        @first_message = first_message
+      end
+
+      # Generate a title for the thread based on first message
+      def call
+        return if @thread.title.present?
+
+        title = generate_title
+        @thread.update!(title:) if title.present?
+      end
+
+      private
+
+        def generate_title
+          content = @first_message.content.to_s.strip
+          return nil if content.blank?
+
+          # Try LLM-based title generation if available
+          llm_title = generate_with_llm(content)
+          return llm_title if llm_title.present?
+
+          # Fallback to simple truncation
+          truncate_content(content)
+        end
+
+        def generate_with_llm(content)
+          return nil unless defined?(RubyLLM)
+
+          response = RubyLLM.chat(model: "claude-haiku-3-5-20241022")
+            .with_instructions("Generate a short, descriptive title (max 50 chars) for a conversation that starts with this message. Return only the title, nothing else.")
+            .ask(content)
+
+          title = response.content.to_s.strip.gsub(/^["']|["']$/, "")
+          title.presence
+        rescue => e
+          Rails.logger.warn("[Aven::Chat] LLM title generation failed: #{e.message}")
+          nil
+        end
+
+        def truncate_content(content)
+          # Take first sentence or first N characters
+          first_sentence = content.split(/[.!?]/).first.to_s.strip
+
+          if first_sentence.length <= MAX_TITLE_LENGTH
+            first_sentence
+          else
+            content.truncate(MAX_TITLE_LENGTH, separator: " ")
+          end
+        end
+    end
+  end
+end

data/app/services/aven/external/gmail_client.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Aven
+  module External
+    class GmailClient
+      class Error < StandardError; end
+
+      GMAIL_API_BASE = "https://gmail.googleapis.com/gmail/v1"
+      PAGE_SIZE = 100
+
+      IGNORED_PATTERNS = %w[
+        noreply no-reply notifications notification
+        mailer-daemon postmaster bounce
+        newsletter news updates update
+        support help info contact
+        donotreply do-not-reply
+      ].freeze
+
+      def initialize(access_token, exclude_emails: [])
+        @access_token = access_token
+        @exclude_emails = Array(exclude_emails).map(&:downcase)
+        @connection = build_connection
+      end
+
+      # Scan emails and extract unique addresses
+      # Returns { emails_scanned: N, addresses: [{ email:, name:, domain: }, ...] }
+      def extract_email_addresses(max_emails: 2000, &progress_callback)
+        addresses = {}
+        emails_scanned = 0
+        page_token = nil
+
+        loop do
+          break if emails_scanned >= max_emails
+
+          messages_response = fetch_messages(
+            page_token:,
+            max_results: [PAGE_SIZE, max_emails - emails_scanned].min
+          )
+          messages = messages_response["messages"] || []
+
+          break if messages.empty?
+
+          messages.each do |msg|
+            break if emails_scanned >= max_emails
+
+            begin
+              message = fetch_message(msg["id"])
+              extract_addresses_from_message(message, addresses)
+              emails_scanned += 1
+              progress_callback&.call(emails_scanned)
+            rescue StandardError => e
+              Rails.logger.warn("Failed to fetch message #{msg['id']}: #{e.message}")
+            end
+          end
+
+          page_token = messages_response["nextPageToken"]
+          break unless page_token
+        end
+
+        {
+          emails_scanned:,
+          addresses: addresses.values
+        }
+      end
+
+      # Extract addresses and create import entries
+      def fetch_into_import(import, max_emails: 2000, &progress_callback)
+        result = extract_email_addresses(max_emails:, &progress_callback)
+
+        result[:addresses].each do |address_data|
+          import.entries.create!(data: address_data)
+        end
+
+        result
+      end
+
+      private
+
+        def build_connection
+          Faraday.new(GMAIL_API_BASE) do |f|
+            f.request :json
+            f.response :json
+            f.adapter Faraday.default_adapter
+          end
+        end
+
+        def fetch_messages(page_token: nil, max_results: PAGE_SIZE)
+          params = { maxResults: max_results }
+          params[:pageToken] = page_token if page_token
+
+          response = @connection.get("users/me/messages", params) do |req|
+            req.headers["Authorization"] = "Bearer #{@access_token}"
+          end
+
+          raise Error, "Gmail API error: #{response.body}" unless response.success?
+
+          response.body
+        end
+
+        def fetch_message(message_id)
+          response = @connection.get("users/me/messages/#{message_id}", { format: "metadata" }) do |req|
+            req.headers["Authorization"] = "Bearer #{@access_token}"
+          end
+
+          raise Error, "Gmail API error: #{response.body}" unless response.success?
+
+          response.body
+        end
+
+        def extract_addresses_from_message(message, addresses)
+          headers = message.dig("payload", "headers") || []
+
+          %w[From To Cc].each do |header_name|
+            header = headers.find { |h| h["name"] == header_name }
+            next unless header
+
+            parse_email_header(header["value"]).each do |parsed|
+              next if ignored_address?(parsed[:email])
+              next if addresses.key?(parsed[:email].downcase)
+
+              addresses[parsed[:email].downcase] = {
+                "email" => parsed[:email],
+                "name" => parsed[:name],
+                "domain" => parsed[:email].split("@").last
+              }
+            end
+          end
+        end
+
+        def parse_email_header(header_value)
+          return [] if header_value.blank?
+
+          results = []
+          parts = header_value.scan(/(?:"[^"]*"|[^,])+/).map(&:strip).reject(&:blank?)
+
+          parts.each do |part|
+            if part =~ /^(?:"?(.+?)"?\s+)?<([^>]+@[^>]+)>$/
+              name = ::Regexp.last_match(1)&.strip
+              email = ::Regexp.last_match(2)&.strip&.downcase
+            elsif part =~ /^([a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,})$/
+              name = nil
+              email = ::Regexp.last_match(1)&.strip&.downcase
+            else
+              next
+            end
+
+            next unless email
+            next unless email.include?("@")
+            next if email.length < 5
+
+            results << { name: name.presence, email: }
+          end
+
+          results
+        end
+
+        def ignored_address?(email)
+          return true if email.blank?
+
+          local_part = email.split("@").first&.downcase || ""
+          domain = email.split("@").last&.downcase || ""
+
+          return true if @exclude_emails.include?(email.downcase)
+          return true if local_part.match?(/^(no[-_]?reply|noreply|do[-_]?not[-_]?reply|mailer[-_]?daemon|postmaster|bounce|daemon)/i)
+          return true if IGNORED_PATTERNS.any? { |keyword| local_part.include?(keyword) }
+          return true if domain == "noreply.github.com"
+          return true if domain.match?(/(^|\.)(substack\.com|beehiiv\.com|medium\.com)$/i)
+
+          false
+        end
+    end
+  end
+end

data/app/services/aven/external/google_contacts_client.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "google/apis/people_v1"
+
+module Aven
+  module External
+    class GoogleContactsClient
+      class Error < StandardError; end
+
+      PERSON_FIELDS = %w[
+        names
+        emailAddresses
+        phoneNumbers
+        organizations
+        photos
+      ].join(",").freeze
+
+      PAGE_SIZE = 100
+
+      def initialize(access_token)
+        @service = Google::Apis::PeopleV1::PeopleServiceService.new
+        @service.authorization = access_token
+      end
+
+      def contacts_count
+        response = @service.list_person_connections(
+          "people/me",
+          person_fields: "metadata",
+          page_size: 1
+        )
+        response.total_items || 0
+      rescue Google::Apis::Error => e
+        raise Error, "Google API error: #{e.message}"
+      end
+
+      def each_contact(&block)
+        page_token = nil
+
+        loop do
+          response = @service.list_person_connections(
+            "people/me",
+            person_fields: PERSON_FIELDS,
+            page_size: PAGE_SIZE,
+            page_token:,
+            sort_order: "LAST_MODIFIED_DESCENDING"
+          )
+
+          (response.connections || []).each do |person|
+            yield normalize_contact(person)
+          end
+
+          page_token = response.next_page_token
+          break unless page_token
+        end
+      rescue Google::Apis::Error => e
+        raise Error, "Google API error: #{e.message}"
+      end
+
+      def fetch_all
+        contacts = []
+        each_contact { |c| contacts << c }
+        contacts
+      end
+
+      # Fetch contacts and create import entries
+      def fetch_into_import(import, &progress_callback)
+        count = 0
+        each_contact do |contact_data|
+          import.entries.create!(data: contact_data)
+          count += 1
+          progress_callback&.call(count)
+        end
+        count
+      end
+
+      private
+
+        def normalize_contact(person)
+          name = person.names&.first
+          emails = person.email_addresses || []
+          phones = person.phone_numbers || []
+          org = person.organizations&.first
+
+          {
+            "google_resource_name" => person.resource_name,
+            "first_name" => name&.given_name,
+            "last_name" => name&.family_name,
+            "email" => emails.first&.value,
+            "phone" => phones.first&.value,
+            "company" => org&.name
+          }.compact
+        end
+    end
+  end
+end

data/app/views/layouts/aven/admin.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html  class='bg-slate-50'>
+  <head>
+    <title>Aven</title>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    <%= yield :head %>
+    <script src="https://cdn.jsdelivr.net/npm/@tailwindplus/elements@1" type="module"></script>
+    <%= stylesheet_link_tag "aven/application", media: "all" %>
+    <%= stylesheet_link_tag "aven/tailwind", media: "all" %>
+    <%= javascript_importmap_tags "aven/application", importmap: Aven.importmap %>
+  </head>
+  <body class='bg-slate-100'>
+    <%= yield %>
+  </body>
+</html>

data/app/views/layouts/aven/application.html.erb

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Aven</title>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    <%= yield :head %>
+    <script src="https://cdn.jsdelivr.net/npm/@tailwindplus/elements@1" type="module"></script>
+    <%= stylesheet_link_tag "aeros/application", media: "all" %>
+    <%= stylesheet_link_tag "aeros/tailwind", media: "all" %>
+    <%= stylesheet_link_tag "aven/application", media: "all" %>
+    <%= stylesheet_link_tag "aven/tailwind", media: "all" %>
+    <%= javascript_importmap_tags "aven/application", importmap: Aven.importmap %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/config/importmap.rb

@@ -0,0 +1,16 @@
+# Engine's own importmap configuration
+pin "@hotwired/turbo-rails", to: "turbo.min.js"
+pin "aven/application"
+pin "@hotwired/stimulus", to: "stimulus.min.js"
+pin "@hotwired/stimulus-loading", to: "stimulus-loading.js"
+
+pin_all_from(
+  Aven::Engine.root.join("app/javascript/aven/controllers"),
+  under: "aven/controllers",
+)
+
+pin_all_from(
+  Aven::Engine.root.join("app/components/aven"),
+  under: "aven/components",
+  to: "aven"
+)

data/config/routes.rb

@@ -0,0 +1,63 @@
+Aven::Engine.routes.draw do
+  # Logout route
+  get(:logout, to: "auth#logout", as: :logout)
+
+  # OAuth routes
+  namespace :oauth do
+    # Error page
+    get "error", to: "base#error", as: :error
+
+    # Google OAuth
+    get "google", to: "google#create", as: :google
+    get "google/callback", to: "google#callback", as: :google_callback
+
+    # GitHub OAuth
+    get "github", to: "github#create", as: :github
+    get "github/callback", to: "github#callback", as: :github_callback
+
+    # Auth0 OAuth
+    get "auth0", to: "auth0#create", as: :auth0
+    get "auth0/callback", to: "auth0#callback", as: :auth0_callback
+  end
+
+  # Workspace switching
+  post("/workspaces/:id/switch", to: "workspaces#switch", as: :switch_workspace)
+
+  # Agentic API routes
+  namespace :agentic do
+    # MCP endpoint
+    match "mcp", to: "mcp#handle", via: [:get, :post, :delete], as: :mcp
+    get "mcp/health", to: "mcp#health", as: :mcp_health
+
+    resources :agents, only: [:index, :show, :create, :update, :destroy]
+    resources :tools, only: [:index, :show, :update]
+    resources :documents, only: [:index, :show, :create, :destroy]
+  end
+
+  # Chat API routes
+  namespace :chat do
+    resources :threads, only: [:index, :show, :create] do
+      member do
+        post :ask
+        post :ask_agent
+      end
+    end
+  end
+
+  # AI text generation (SSE streaming)
+  namespace :ai do
+    post "text/generate", to: "text#generate", as: :text_generate
+  end
+
+  # Tags API (for tagging component)
+  resources :tags, only: [:index, :create]
+
+  # Articles
+  resources :articles
+
+  namespace(:admin) do
+    root(to: "dashboard#index")
+  end
+
+  root(to: "static#index")
+end

data/db/migrate/20200101000001_create_aven_users.rb

@@ -0,0 +1,19 @@
+class CreateAvenUsers < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_users do |t|
+      t.string(:email, default: "", null: false)
+      t.string(:encrypted_password, default: "", null: false)
+      t.string(:reset_password_token)
+      t.datetime(:reset_password_sent_at)
+      t.datetime(:remember_created_at)
+      t.string(:auth_tenant)
+      t.string(:remote_id)
+      t.string(:access_token)
+      t.boolean(:admin, default: false, null: false)
+      t.timestamps
+    end
+
+    add_index(:aven_users, [ :email, :auth_tenant ], unique: true)
+    add_index(:aven_users, :reset_password_token, unique: true)
+  end
+end

data/db/migrate/20200101000002_create_aven_workspaces.rb

@@ -0,0 +1,14 @@
+class CreateAvenWorkspaces < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_workspaces do |t|
+      t.string :label
+      t.string :slug
+      t.text :description
+      t.string :domain
+
+      t.timestamps
+    end
+
+    add_index :aven_workspaces, :slug, unique: true
+  end
+end

data/db/migrate/20200101000003_create_aven_workspace_users.rb

@@ -0,0 +1,12 @@
+class CreateAvenWorkspaceUsers < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_workspace_users do |t|
+      t.references :user, null: false, foreign_key: { to_table: :aven_users }
+      t.references :workspace, null: false, foreign_key: { to_table: :aven_workspaces }
+
+      t.timestamps
+    end
+
+    add_index :aven_workspace_users, [ :user_id, :workspace_id ], unique: true, name: "idx_aven_workspace_users_on_user_workspace"
+  end
+end

data/db/migrate/20200101000004_create_aven_workspace_roles.rb

@@ -0,0 +1,13 @@
+class CreateAvenWorkspaceRoles < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_workspace_roles do |t|
+      t.references :workspace, foreign_key: { to_table: :aven_workspaces }
+      t.string :label, null: false
+      t.string :description
+
+      t.timestamps
+    end
+
+    add_index :aven_workspace_roles, [ :workspace_id, :label ], unique: true, name: "idx_aven_workspace_roles_on_ws_label"
+  end
+end

data/db/migrate/20200101000005_create_aven_workspace_user_roles.rb

@@ -0,0 +1,12 @@
+class CreateAvenWorkspaceUserRoles < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_workspace_user_roles do |t|
+      t.references :workspace_role, foreign_key: { to_table: :aven_workspace_roles }
+      t.references :workspace_user, foreign_key: { to_table: :aven_workspace_users }
+
+      t.timestamps
+    end
+
+    add_index :aven_workspace_user_roles, [ :workspace_role_id, :workspace_user_id ], unique: true, name: "idx_aven_ws_user_roles_on_role_user"
+  end
+end

data/db/migrate/20200101000006_create_aven_logs.rb

@@ -0,0 +1,21 @@
+class CreateAvenLogs < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_logs do |t|
+      t.string :level, null: false, default: "info"
+      t.string :loggable_type, null: false
+      t.bigint :loggable_id, null: false
+      t.text :message, null: false
+      t.jsonb :metadata
+      t.string :state
+      t.string :state_machine
+      t.string :run_id
+      t.references :workspace, null: false, foreign_key: { to_table: :aven_workspaces }
+      t.timestamps
+    end
+
+    add_index :aven_logs, :created_at
+    add_index :aven_logs, :level
+    add_index :aven_logs, [ :loggable_type, :loggable_id ], name: "index_aven_logs_on_loggable"
+    add_index :aven_logs, [ :loggable_type, :loggable_id, :run_id, :state, :created_at ], name: "idx_aven_logs_on_loggable_run_state_created_at"
+  end
+end

data/db/migrate/20200101000009_create_aven_items.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateAvenItems < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_items do |t|
+      t.references :workspace, null: false, foreign_key: { to_table: :aven_workspaces }
+      t.string :schema_slug, null: false
+      t.jsonb :data, null: false, default: {}
+      t.datetime :deleted_at
+      t.timestamps
+    end
+
+    add_index :aven_items, :schema_slug
+    add_index :aven_items, :data, using: :gin
+    add_index :aven_items, :deleted_at
+  end
+end

data/db/migrate/20200101000010_create_aven_item_links.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CreateAvenItemLinks < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_item_links do |t|
+      t.references :source, null: false, foreign_key: { to_table: :aven_items }
+      t.references :target, null: false, foreign_key: { to_table: :aven_items }
+      t.string :relation, null: false
+      t.integer :position, default: 0
+      t.timestamps
+    end
+
+    add_index :aven_item_links, [:source_id, :relation]
+    add_index :aven_item_links, [:target_id, :relation]
+    add_index :aven_item_links, [:source_id, :target_id, :relation], unique: true
+  end
+end

data/db/migrate/20200101000011_create_aven_agentic_tools.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateAvenAgenticTools < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_agentic_tools do |t|
+      t.references :workspace, foreign_key: { to_table: :aven_workspaces }
+      t.string :name, null: false
+      t.string :class_name, null: false
+      t.text :description
+      t.text :default_description
+      t.boolean :enabled, default: true, null: false
+      t.timestamps
+    end
+
+    add_index :aven_agentic_tools, [:workspace_id, :name], unique: true
+    add_index :aven_agentic_tools, [:workspace_id, :class_name], unique: true
+    add_index :aven_agentic_tools, :enabled
+  end
+end

data/db/migrate/20200101000012_create_aven_agentic_tool_parameters.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class CreateAvenAgenticToolParameters < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_agentic_tool_parameters do |t|
+      t.references :tool, null: false, foreign_key: { to_table: :aven_agentic_tools }
+      t.string :name, null: false
+      t.string :param_type, null: false
+      t.text :description
+      t.text :default_description
+      t.boolean :required, default: false, null: false
+      t.jsonb :constraints, default: {}
+      t.integer :position, default: 0, null: false
+      t.timestamps
+    end
+
+    add_index :aven_agentic_tool_parameters, [:tool_id, :name], unique: true
+    add_index :aven_agentic_tool_parameters, [:tool_id, :position]
+  end
+end

data/db/migrate/20200101000013_create_aven_agentic_documents.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class CreateAvenAgenticDocuments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :aven_agentic_documents do |t|
+      t.references :workspace, null: false, foreign_key: { to_table: :aven_workspaces }
+      t.string :filename, null: false
+      t.string :content_type, null: false
+      t.bigint :byte_size, null: false
+      t.string :ocr_status, default: "pending", null: false
+      t.text :ocr_content
+      t.string :embedding_status, default: "pending", null: false
+      t.jsonb :metadata, default: {}
+      t.datetime :processed_at
+      t.timestamps
+    end
+
+    add_index :aven_agentic_documents, :ocr_status
+    add_index :aven_agentic_documents, :embedding_status
+    add_index :aven_agentic_documents, :content_type
+  end
+end

data/db/migrate/20200101000014_create_aven_agentic_document_embeddings.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateAvenAgenticDocumentEmbeddings < ActiveRecord::Migration[8.0]
+  def change
+    # Enable pgvector extension for vector similarity search
+    enable_extension "vector"
+
+    create_table :aven_agentic_document_embeddings do |t|
+      t.references :document, null: false, foreign_key: { to_table: :aven_agentic_documents }
+      t.integer :chunk_index, null: false
+      t.text :content, null: false
+      t.vector :embedding, limit: 1536  # OpenAI ada-002 dimensions
+      t.timestamps
+    end
+
+    add_index :aven_agentic_document_embeddings, [:document_id, :chunk_index], unique: true
+  end
+end