aven 0.0.3

data/app/controllers/aven/oauth/github_controller.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Aven
+  module Oauth
+    class GithubController < BaseController
+      AUTHORIZATION_URL = "https://github.com/login/oauth/authorize"
+      TOKEN_URL = "https://github.com/login/oauth/access_token"
+      USER_INFO_URL = "https://api.github.com/user"
+      USER_EMAIL_URL = "https://api.github.com/user/emails"
+      DEFAULT_SCOPE = "user:email"
+
+      protected
+
+        def authorization_url(state)
+          params = {
+            client_id: oauth_config[:client_id],
+            redirect_uri: callback_url,
+            scope: oauth_config[:scope] || DEFAULT_SCOPE,
+            state:
+          }
+
+          "#{AUTHORIZATION_URL}?#{params.to_query}"
+        end
+
+        def exchange_code_for_token(code)
+          params = {
+            client_id: oauth_config[:client_id],
+            client_secret: oauth_config[:client_secret],
+            code:,
+            redirect_uri: callback_url
+          }
+
+          headers = { "Accept" => "application/json" }
+          oauth_request(URI(TOKEN_URL), params, headers)
+        end
+
+        def fetch_user_info(access_token)
+          # Fetch user profile
+          user_data = github_api_request(USER_INFO_URL, access_token)
+
+          # Fetch primary email if not public
+          email = user_data[:email]
+          if email.blank?
+            emails_data = github_api_request(USER_EMAIL_URL, access_token)
+            primary_email = emails_data.find { |e| e[:primary] && e[:verified] }
+            email = primary_email[:email] if primary_email
+          end
+
+          {
+            id: user_data[:id],
+            email:,
+            name: user_data[:name] || user_data[:login],
+            avatar_url: user_data[:avatar_url],
+            login: user_data[:login]
+          }
+        end
+
+      private
+
+        def callback_url
+          aven.oauth_github_callback_url(host: request.host, protocol: request.protocol)
+        end
+
+        def oauth_config
+          @oauth_config ||= Aven.configuration.oauth_providers[:github] || raise("GitHub OAuth not configured")
+        end
+
+        def github_api_request(url, access_token)
+          uri = URI(url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE if Rails.env.development?
+
+          request = Net::HTTP::Get.new(uri)
+          request["Authorization"] = "Bearer #{access_token}"
+          request["Accept"] = "application/vnd.github.v3+json"
+
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise StandardError, "GitHub API request failed: #{response.body}"
+          end
+
+          JSON.parse(response.body, symbolize_names: true)
+        end
+    end
+  end
+end

data/app/controllers/aven/oauth/google_controller.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Aven
+  module Oauth
+    class GoogleController < BaseController
+      AUTHORIZATION_URL = "https://accounts.google.com/o/oauth2/v2/auth"
+      TOKEN_URL = "https://www.googleapis.com/oauth2/v4/token"
+      USER_INFO_URL = "https://www.googleapis.com/oauth2/v3/userinfo"
+      DEFAULT_SCOPE = "openid email profile"
+
+      protected
+
+        def authorization_url(state)
+          params = {
+            client_id: oauth_config[:client_id],
+            redirect_uri: callback_url,
+            response_type: "code",
+            scope: oauth_config[:scope] || DEFAULT_SCOPE,
+            state:,
+            access_type: oauth_config[:access_type] || "offline",
+            prompt: oauth_config[:prompt] || "select_account"
+          }
+
+          "#{AUTHORIZATION_URL}?#{params.to_query}"
+        end
+
+        def exchange_code_for_token(code)
+          params = {
+            code:,
+            client_id: oauth_config[:client_id],
+            client_secret: oauth_config[:client_secret],
+            redirect_uri: callback_url,
+            grant_type: "authorization_code"
+          }
+
+          oauth_request(URI(TOKEN_URL), params)
+        end
+
+        def fetch_user_info(access_token)
+          response = oauth_get_request(URI(USER_INFO_URL), access_token)
+
+          {
+            id: response[:sub],
+            email: response[:email],
+            name: response[:name],
+            picture: response[:picture]
+          }
+        end
+
+      private
+
+        def callback_url
+          aven.oauth_google_callback_url(host: request.host, protocol: request.protocol)
+        end
+
+        def oauth_config
+          @oauth_config ||= Aven.configuration.oauth_providers[:google] || raise("Google OAuth not configured")
+        end
+    end
+  end
+end

data/app/controllers/aven/static_controller.rb

@@ -0,0 +1,7 @@
+module Aven
+  class StaticController < ApplicationController
+    def index
+      view_component("static/index", current_user:)
+    end
+  end
+end

data/app/controllers/aven/tags_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Aven
+  class TagsController < Aven::ApplicationController
+    include Aven::Authentication
+
+    before_action :authenticate_user!
+
+    # GET /tags or /tags.json
+    # Supports search via ?q= parameter
+    def index
+      tags = ActsAsTaggableOn::Tag.all
+
+      if params[:q].present?
+        tags = tags.where("name ILIKE ?", "%#{params[:q]}%")
+      end
+
+      tags = tags.order(:name).limit(params[:limit] || 50)
+
+      respond_to do |format|
+        format.html { render plain: tags.pluck(:name).join(", ") }
+        format.json { render json: tags.pluck(:name) }
+      end
+    end
+
+    # POST /tags or /tags.json
+    # Creates a new tag
+    def create
+      tag_name = params.dig(:tag, :name) || params[:name]
+
+      if tag_name.blank?
+        render json: { error: "Name is required" }, status: :unprocessable_entity
+        return
+      end
+
+      tag = ActsAsTaggableOn::Tag.find_or_create_by(name: tag_name.strip)
+
+      respond_to do |format|
+        format.html { redirect_to tags_path, notice: "Tag created" }
+        format.json { render json: { id: tag.id, name: tag.name }, status: :created }
+      end
+    end
+  end
+end

data/app/controllers/aven/workspaces_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Aven
+  class WorkspacesController < ApplicationController
+    before_action :authenticate_user!
+
+    # POST /workspaces/:id/switch
+    def switch
+      workspace = current_user.workspaces.friendly.find(params[:id])
+      self.current_workspace = workspace
+      redirect_to after_switch_workspace_path, notice: "Switched to #{workspace.label}"
+    end
+
+    private
+
+      def after_switch_workspace_path
+        Aven.configuration.resolve_authenticated_root_path || root_path
+      end
+  end
+end

data/app/controllers/concerns/aven/authentication.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Aven
+  module Authentication
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_user if respond_to?(:helper_method)
+    end
+
+    private
+      # Returns the currently signed-in user, if any
+      def current_user
+        @current_user ||= Aven::User.find_by(id: session[:user_id]) if session[:user_id]
+      end
+
+      # Signs in the given user by setting the session
+      def sign_in(user)
+        reset_session
+        session[:user_id] = user.id
+        @current_user = user
+      end
+
+      # Signs out the current user by clearing the session
+      def sign_out
+        reset_session
+        @current_user = nil
+      end
+
+      # Stores the current location to redirect back after authentication
+      def store_location
+        session[:return_to_after_authentication] = request.url if request.get?
+      end
+
+      # Returns and clears the stored location for redirect after authentication
+      # This method accepts a resource parameter for API compatibility with Devise
+      def stored_location_for(_resource = nil)
+        session.delete(:return_to_after_authentication)
+      end
+
+      # Requires user to be authenticated, redirects to root if not
+      def authenticate_user!
+        unless current_user
+          store_location
+          redirect_to main_app.root_path, alert: "You must be signed in to access this page."
+        end
+      end
+  end
+end

data/app/controllers/concerns/aven/controller_helpers.rb

@@ -0,0 +1,38 @@
+module Aven
+  module ControllerHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_workspace if respond_to?(:helper_method)
+    end
+
+    # Get the current workspace from session
+    def current_workspace
+      return @current_workspace if defined?(@current_workspace)
+
+      @current_workspace = if session[:workspace_id].present? && current_user
+        current_user.workspaces.find_by(id: session[:workspace_id])
+      elsif current_user
+        # Auto-select first workspace if none selected
+        workspace = current_user.workspaces.first
+        session[:workspace_id] = workspace&.id
+        workspace
+      end
+    end
+
+    # Set the current workspace
+    def current_workspace=(workspace)
+      @current_workspace = workspace
+      session[:workspace_id] = workspace&.id
+    end
+
+    # Verify user has access to current workspace (similar to Devise's authenticate_user!)
+    def verify_workspace!
+      return unless current_user.present? && current_workspace.present?
+
+      unless current_user.workspaces.exists?(id: current_workspace.id)
+        render file: Rails.public_path.join("404.html"), status: :not_found, layout: false
+      end
+    end
+  end
+end

data/app/helpers/aven/application_helper.rb

@@ -0,0 +1,16 @@
+module Aven
+  module ApplicationHelper
+    def aven_importmap_tags(entry_point = "application", shim: true)
+      safe_join [
+        javascript_inline_importmap_tag(Aven.importmap.to_json(resolver: self)),
+        javascript_importmap_module_preload_tags(Aven.importmap),
+        javascript_import_module_tag(entry_point)
+      ].compact, "\n"
+    end
+
+    def view_component(name, *args, **kwargs, &block)
+      component = "Aven::Views::#{name.split("/").map(&:camelize).join("::")}::Component".constantize
+      render(component.new(*args, **kwargs), &block)
+    end
+  end
+end

data/app/javascript/aven/application.js

@@ -0,0 +1,3 @@
+// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
+import "@hotwired/turbo-rails";
+import "aven/controllers";

data/app/javascript/aven/controllers/application.js

@@ -0,0 +1,5 @@
+import { Application } from "@hotwired/stimulus";
+const application = Application.start();
+application.debug = false;
+window.Stimulus = application;
+export { application };

data/app/javascript/aven/controllers/index.js

@@ -0,0 +1,11 @@
+import { application } from "aven/controllers/application";
+import { eagerLoadEngineControllersFrom } from "aeros/controllers/loader";
+
+// Load controllers from the standard controllers directory
+eagerLoadEngineControllersFrom("aven/controllers", application);
+
+// Load component controllers
+eagerLoadEngineControllersFrom("aven/components", application);
+
+// Load UI gem component controllers
+eagerLoadEngineControllersFrom("aeros/components", application);

data/app/jobs/aven/agentic/document_embedding_job.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    class DocumentEmbeddingJob < Aven::ApplicationJob
+      queue_as :default
+
+      def perform(document_id)
+        document = Aven::Agentic::Document.find_by(id: document_id)
+        return unless document
+        return unless document.embedding_status == "pending"
+        return unless document.ocr_content.present?
+
+        document.mark_embedding_processing!
+
+        # Generate embeddings for document chunks
+        document.generate_embeddings!
+
+        # TODO: Call embedding API to fill in vector embeddings
+        # For now, just mark as completed without actual embeddings
+        document.mark_embedding_completed!
+      rescue => e
+        Rails.logger.error("[Aven::Embedding] Job failed for document #{document_id}: #{e.message}")
+        document&.mark_embedding_failed!(e.message)
+      end
+    end
+  end
+end

data/app/jobs/aven/agentic/document_ocr_job.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    class DocumentOcrJob < Aven::ApplicationJob
+      queue_as :default
+
+      def perform(document_id)
+        document = Aven::Agentic::Document.find_by(id: document_id)
+        return unless document
+        return unless document.ocr_status == "pending"
+
+        document.mark_ocr_processing!
+
+        content = Aven::Agentic::Ocr::Processor.process(document)
+
+        if content.present?
+          document.mark_ocr_completed!(content)
+        else
+          document.mark_ocr_skipped!
+        end
+      rescue => e
+        Rails.logger.error("[Aven::OCR] Job failed for document #{document_id}: #{e.message}")
+        document&.mark_ocr_failed!(e.message)
+      end
+    end
+  end
+end

data/app/jobs/aven/application_job.rb

@@ -0,0 +1,4 @@
+module Aven
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/jobs/aven/chat/calculate_cost_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Aven
+  module Chat
+    class CalculateCostJob < Aven::ApplicationJob
+      queue_as :low
+
+      def perform(message_id)
+        message = Aven::Chat::Message.find_by(id: message_id)
+        return unless message
+        return unless message.model.present?
+        return if message.cost_usd.to_f > 0
+
+        cost = Config.calculate_cost(
+          input_tokens: message.input_tokens,
+          output_tokens: message.output_tokens,
+          model_id: message.model
+        )
+
+        message.update!(cost_usd: cost) if cost
+      rescue => e
+        Rails.logger.warn("[Aven::Chat] Cost calculation failed for message #{message_id}: #{e.message}")
+      end
+    end
+  end
+end

data/app/jobs/aven/chat/run_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aven
+  module Chat
+    class RunJob < Aven::ApplicationJob
+      queue_as :default
+
+      def perform(thread_id, user_message_id = nil)
+        thread = Aven::Chat::Thread.find_by(id: thread_id)
+        return unless thread
+
+        user_message = if user_message_id
+          thread.messages.find_by(id: user_message_id)
+        else
+          thread.messages.where(role: :user).order(:created_at).last
+        end
+
+        return unless user_message
+
+        Aven::Chat::Orchestrator.new(thread).run(user_message)
+      rescue => e
+        Rails.logger.error("[Aven::Chat] RunJob failed for thread #{thread_id}: #{e.message}")
+        Rails.logger.error(e.backtrace.first(10).join("\n"))
+      end
+    end
+  end
+end

data/app/mailers/aven/application_mailer.rb

@@ -0,0 +1,6 @@
+module Aven
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_agents
+#
+#  id                   :bigint           not null, primary key
+#  enabled              :boolean          default(TRUE), not null
+#  label                :string           not null
+#  slug                 :string
+#  system_prompt        :text
+#  user_facing_question :text
+#  created_at           :datetime         not null
+#  updated_at           :datetime         not null
+#  workspace_id         :bigint           not null
+#
+# Indexes
+#
+#  index_aven_agentic_agents_on_enabled                (enabled)
+#  index_aven_agentic_agents_on_workspace_id           (workspace_id)
+#  index_aven_agentic_agents_on_workspace_id_and_slug  (workspace_id,slug) UNIQUE
+#
+# Foreign Keys
+#
+#  fk_rails_...  (workspace_id => aven_workspaces.id)
+#
+module Aven
+  module Agentic
+    class Agent < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_agents"
+
+      include Aven::Model::TenantModel
+
+      extend FriendlyId
+      friendly_id :label, use: [:slugged, :scoped], scope: :workspace
+
+      has_many :agent_tools,
+               class_name: "Aven::Agentic::AgentTool",
+               foreign_key: :agent_id,
+               dependent: :destroy,
+               inverse_of: :agent
+
+      has_many :tools, through: :agent_tools
+
+      has_many :agent_documents,
+               class_name: "Aven::Agentic::AgentDocument",
+               foreign_key: :agent_id,
+               dependent: :destroy,
+               inverse_of: :agent
+
+      has_many :documents, through: :agent_documents
+
+      has_many :threads,
+               class_name: "Aven::Chat::Thread",
+               foreign_key: :agent_id,
+               dependent: :nullify
+
+      accepts_nested_attributes_for :agent_tools, allow_destroy: true
+      accepts_nested_attributes_for :agent_documents, allow_destroy: true
+
+      validates :label, presence: true
+
+      scope :enabled, -> { where(enabled: true) }
+
+      # Returns tool names for this agent (used when locking thread tools)
+      def tool_names
+        tools.pluck(:name)
+      end
+
+      # Returns document IDs for this agent (used when locking thread documents)
+      def document_ids
+        documents.pluck(:id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_agent_documents
+#
+#  id          :bigint           not null, primary key
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  agent_id    :bigint           not null
+#  document_id :bigint           not null
+#
+# Indexes
+#
+#  index_aven_agentic_agent_documents_on_agent_id                  (agent_id)
+#  index_aven_agentic_agent_documents_on_agent_id_and_document_id  (agent_id,document_id) UNIQUE
+#  index_aven_agentic_agent_documents_on_document_id               (document_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (agent_id => aven_agentic_agents.id)
+#  fk_rails_...  (document_id => aven_agentic_documents.id)
+#
+module Aven
+  module Agentic
+    class AgentDocument < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_agent_documents"
+
+      belongs_to :agent, class_name: "Aven::Agentic::Agent", inverse_of: :agent_documents
+      belongs_to :document, class_name: "Aven::Agentic::Document", inverse_of: :agent_documents
+
+      validates :document_id, uniqueness: { scope: :agent_id }
+
+      delegate :workspace, :workspace_id, to: :agent
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# == Schema Information
+#
+# Table name: aven_agentic_agent_tools
+#
+#  id         :bigint           not null, primary key
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#  agent_id   :bigint           not null
+#  tool_id    :bigint           not null
+#
+# Indexes
+#
+#  index_aven_agentic_agent_tools_on_agent_id              (agent_id)
+#  index_aven_agentic_agent_tools_on_agent_id_and_tool_id  (agent_id,tool_id) UNIQUE
+#  index_aven_agentic_agent_tools_on_tool_id               (tool_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (agent_id => aven_agentic_agents.id)
+#  fk_rails_...  (tool_id => aven_agentic_tools.id)
+#
+module Aven
+  module Agentic
+    class AgentTool < Aven::ApplicationRecord
+      self.table_name = "aven_agentic_agent_tools"
+
+      belongs_to :agent, class_name: "Aven::Agentic::Agent", inverse_of: :agent_tools
+      belongs_to :tool, class_name: "Aven::Agentic::Tool", inverse_of: :agent_tools
+
+      validates :tool_id, uniqueness: { scope: :agent_id }
+
+      delegate :workspace, :workspace_id, to: :agent
+    end
+  end
+end