aven 0.0.3

data/app/models/concerns/aven/searchable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Aven
+  module Searchable
+    extend ActiveSupport::Concern
+
+    included do
+      include PgSearch::Model
+    end
+
+    class_methods do
+      # DSL for configuring search
+      #
+      # @example Basic usage
+      #   class Product < ApplicationRecord
+      #     include Aven::Searchable
+      #
+      #     searchable against: [:name, :description]
+      #   end
+      #
+      # @example With options
+      #   searchable against: [:name, :description],
+      #              using: { tsearch: { prefix: true, dictionary: "english" } },
+      #              ranked_by: ":tsearch"
+      #
+      # @example With associations
+      #   searchable against: [:title],
+      #              associated_against: { author: :name, tags: :label }
+      #
+      # @example With tsvector column (for performance)
+      #   searchable against: [:name, :description],
+      #              using: { tsearch: { tsvector_column: "searchable" } }
+      #
+      def searchable(against:, **options)
+        pg_search_scope(:search,
+          against:,
+          **options.reverse_merge(
+            using: {
+              tsearch: { prefix: true, negation: true }
+            }
+          ))
+
+        # Convenience scope for workspace + search
+        if column_names.include?("workspace_id")
+          scope :search_in_workspace, ->(workspace, query) {
+            where(workspace_id: workspace.id).search(query)
+          }
+        end
+      end
+
+      # Multi-search registration (global search across models)
+      #
+      # @example
+      #   searchable_globally against: [:name, :description]
+      #
+      def searchable_globally(against:, **options)
+        multisearchable against:, **options
+      end
+    end
+  end
+end

data/app/services/aven/agentic/dynamic_tool_builder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    class DynamicToolBuilder
+      class << self
+        # Build a RubyLLM tool from a database record
+        # @param tool_record [Aven::Agentic::Tool] Database record
+        # @return [Class] RubyLLM::Tool subclass
+        def build(tool_record)
+          return nil unless tool_record.valid_class?
+
+          tool_class = tool_record.tool_class
+          tool_description = tool_record.effective_description
+          tool_parameters = tool_record.parameters.to_a
+          tool_name = tool_record.name
+
+          # Create dynamic RubyLLM tool class
+          Class.new(RubyLLM::Tool) do
+            @search_tool_class = tool_class
+            @tool_record = tool_record
+            @tool_name = tool_name
+
+            class << self
+              attr_reader :search_tool_class, :tool_record, :tool_name
+            end
+
+            description tool_description
+
+            # Build parameters using param DSL
+            tool_parameters.each do |p|
+              param_name = p.name.to_sym
+              param_desc = p.effective_description
+              param_type = case p.param_type.to_sym
+              when :integer, :float then :number
+              when :array then :array
+              when :boolean then :boolean
+              else :string
+              end
+
+              param param_name, type: param_type, desc: param_desc, required: p.required?
+            end
+
+            # Override name instance method
+            def name
+              self.class.tool_name
+            end
+
+            # Execute delegates to actual tool class
+            def execute(**params)
+              result = self.class.search_tool_class.call(**params)
+              Aven::Agentic::ToolResultFormatter.format(self.class.tool_name, result)
+            end
+          end
+        end
+
+        # Build all enabled tools for a workspace
+        # @param workspace [Aven::Workspace, nil] Workspace to scope tools
+        # @return [Array<Class>] Array of RubyLLM::Tool subclasses
+        def build_all(workspace: nil)
+          scope = Aven::Agentic::Tool.enabled.includes(:parameters)
+          scope = scope.for_workspace(workspace) if workspace
+
+          scope.map { |tool_record| build(tool_record) }.compact
+        end
+
+        # Get cached tool or build fresh
+        def cached_build(tool_record)
+          @tool_cache ||= {}
+          cache_key = "#{tool_record.id}/#{tool_record.updated_at.to_f}"
+
+          @tool_cache[cache_key] ||= build(tool_record)
+        end
+
+        def clear_cache!
+          @tool_cache = {}
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/mcp/adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Mcp
+      class Adapter
+        def initialize(tool_class, context = {})
+          @tool_class = tool_class
+          @context = context
+        end
+
+        # Convert tool to MCP tool format
+        def to_mcp_tool
+          {
+            name: tool_name,
+            description: tool_description,
+            input_schema: build_input_schema,
+            handler: method(:handle)
+          }
+        end
+
+        # Handle MCP tool call
+        def handle(params)
+          result = @tool_class.new.execute(**params.symbolize_keys)
+          ResultFormatter.format(result)
+        rescue => e
+          Rails.logger.error("[Aven::MCP] Tool execution error: #{e.message}")
+          ResultFormatter.format_error(e)
+        end
+
+        private
+
+          def tool_name
+            @tool_class.tool_name
+          end
+
+          def tool_description
+            @tool_class.class.tool_record&.effective_description || "No description"
+          end
+
+          def build_input_schema
+            properties = {}
+            required = []
+
+            tool_record = @tool_class.class.tool_record
+            return { type: "object", properties: {} } unless tool_record
+
+            tool_record.parameters.each do |param|
+              properties[param.name] = {
+                type: json_schema_type(param.param_type),
+                description: param.effective_description
+              }
+
+              required << param.name if param.required?
+            end
+
+            {
+              type: "object",
+              properties:,
+              required:
+            }
+          end
+
+          def json_schema_type(param_type)
+            case param_type.to_sym
+            when :integer then "integer"
+            when :float then "number"
+            when :boolean then "boolean"
+            when :array then "array"
+            when :object then "object"
+            else "string"
+            end
+          end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/mcp/result_formatter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Mcp
+      class ResultFormatter
+        class << self
+          # Format successful result for MCP response
+          # @param result [Object] Tool execution result
+          # @return [Hash] MCP-formatted result
+          def format(result)
+            {
+              content: [
+                {
+                  type: "text",
+                  text: format_content(result)
+                }
+              ]
+            }
+          end
+
+          # Format error for MCP response
+          # @param error [Exception] Error that occurred
+          # @return [Hash] MCP-formatted error
+          def format_error(error)
+            {
+              content: [
+                {
+                  type: "text",
+                  text: "Error: #{error.message}"
+                }
+              ],
+              isError: true
+            }
+          end
+
+          private
+
+            def format_content(result)
+              case result
+              when String
+                result
+              when Hash
+                JSON.pretty_generate(result)
+              when Array
+                result.map { |item| format_content(item) }.join("\n\n")
+              when nil
+                "No result"
+              else
+                result.to_s
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/mcp/server_factory.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Mcp
+      class ServerFactory
+        SERVER_NAME = "aven-mcp-server"
+        SERVER_VERSION = Aven::VERSION
+
+        class << self
+          # Build an MCP server instance
+          # @param server_context [Hash] Context data for the server
+          # @return [MCP::Server] Configured MCP server
+          def build(server_context: {})
+            return nil unless defined?(::MCP::Server)
+
+            server = ::MCP::Server.new(
+              name: SERVER_NAME,
+              version: SERVER_VERSION
+            )
+
+            # Register tools
+            register_tools(server, server_context)
+
+            server
+          end
+
+          private
+
+            def register_tools(server, context)
+              workspace = context[:workspace]
+              tools = Aven::Agentic::DynamicToolBuilder.build_all(workspace:)
+
+              tools.each do |tool_class|
+                adapter = Adapter.new(tool_class, context)
+                server.register_tool(adapter.to_mcp_tool)
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/base_extractor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class BaseExtractor
+        class << self
+          # Extract text from document
+          # @param document [Aven::Agentic::Document]
+          # @return [String, nil] Extracted text
+          def extract(document)
+            raise NotImplementedError, "#{name} must implement extract"
+          end
+
+          protected
+
+            # Download file to temp location
+            def with_tempfile(document, &block)
+              return nil unless document.file.attached?
+
+              extension = File.extname(document.filename)
+              tempfile = Tempfile.new(["aven_ocr", extension])
+
+              begin
+                tempfile.binmode
+                tempfile.write(document.file.download)
+                tempfile.rewind
+
+                yield tempfile.path
+              ensure
+                tempfile.close
+                tempfile.unlink
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/excel_extractor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class ExcelExtractor < BaseExtractor
+        class << self
+          def extract(document)
+            with_tempfile(document) do |path|
+              extract_xlsx(path)
+            end
+          end
+
+          private
+
+            def extract_xlsx(path)
+              # Use roo gem if available
+              if defined?(Roo::Spreadsheet)
+                xlsx = Roo::Spreadsheet.open(path)
+                sheets = []
+
+                xlsx.sheets.each do |sheet_name|
+                  sheet = xlsx.sheet(sheet_name)
+                  rows = sheet.each.map do |row|
+                    row.map { |cell| cell.to_s.strip }.join("\t")
+                  end
+                  sheets << "## #{sheet_name}\n\n#{rows.join("\n")}"
+                end
+
+                sheets.join("\n\n---\n\n")
+              else
+                Rails.logger.warn("[Aven::OCR] roo gem not available")
+                nil
+              end
+            rescue => e
+              Rails.logger.error("[Aven::OCR] Excel extraction failed: #{e.message}")
+              nil
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/image_extractor.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class ImageExtractor < BaseExtractor
+        class << self
+          def extract(document)
+            with_tempfile(document) do |path|
+              if Aven.configuration.ocr&.provider == :textract
+                TextractClient.extract_document(path)
+              else
+                Rails.logger.warn("[Aven::OCR] No OCR provider configured for images")
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/pdf_extractor.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class PdfExtractor < BaseExtractor
+        class << self
+          def extract(document)
+            with_tempfile(document) do |path|
+              # Try text extraction first (for text-based PDFs)
+              text = extract_text_layer(path)
+              return text if text.present?
+
+              # Fall back to OCR for scanned PDFs
+              extract_with_ocr(path)
+            end
+          end
+
+          private
+
+            def extract_text_layer(path)
+              # Use pdf-reader gem if available
+              if defined?(PDF::Reader)
+                reader = PDF::Reader.new(path)
+                text = reader.pages.map(&:text).join("\n\n")
+                return text if text.strip.present?
+              end
+
+              nil
+            rescue => e
+              Rails.logger.warn("[Aven::OCR] PDF text extraction failed: #{e.message}")
+              nil
+            end
+
+            def extract_with_ocr(path)
+              # Use AWS Textract if configured
+              if Aven.configuration.ocr&.provider == :textract
+                TextractClient.extract_document(path)
+              else
+                Rails.logger.warn("[Aven::OCR] No OCR provider configured")
+                nil
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/processor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class Processor
+        class << self
+          # Process a document and extract text content
+          # @param document [Aven::Agentic::Document]
+          # @return [String, nil] Extracted text content
+          def process(document)
+            extractor = extractor_for(document)
+            return nil unless extractor
+
+            extractor.extract(document)
+          end
+
+          private
+
+            def extractor_for(document)
+              case
+              when document.pdf?
+                PdfExtractor
+              when document.image?
+                ImageExtractor
+              when document.word_doc?
+                WordExtractor
+              when document.excel?
+                ExcelExtractor
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/textract_client.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class TextractClient
+        class << self
+          # Extract text from document using AWS Textract
+          # @param file_path [String] Path to the file
+          # @return [String, nil] Extracted text
+          def extract_document(file_path)
+            client = build_client
+            return nil unless client
+
+            bytes = File.binread(file_path)
+
+            response = client.detect_document_text(
+              document: { bytes: }
+            )
+
+            extract_text_from_response(response)
+          rescue Aws::Textract::Errors::ServiceError => e
+            Rails.logger.error("[Aven::Textract] API error: #{e.message}")
+            nil
+          end
+
+          # Extract text from multi-page document (async)
+          # @param s3_bucket [String] S3 bucket name
+          # @param s3_key [String] S3 object key
+          # @return [String, nil] Extracted text
+          def extract_document_async(s3_bucket:, s3_key:)
+            client = build_client
+            return nil unless client
+
+            # Start async job
+            start_response = client.start_document_text_detection(
+              document_location: {
+                s3_object: {
+                  bucket: s3_bucket,
+                  name: s3_key
+                }
+              }
+            )
+
+            job_id = start_response.job_id
+            wait_for_job(client, job_id)
+          rescue Aws::Textract::Errors::ServiceError => e
+            Rails.logger.error("[Aven::Textract] Async API error: #{e.message}")
+            nil
+          end
+
+          private
+
+            def build_client
+              return nil unless defined?(Aws::Textract::Client)
+
+              config = Aven.configuration.ocr
+              return nil unless config&.aws_region
+
+              Aws::Textract::Client.new(
+                region: config.aws_region,
+                credentials: aws_credentials(config)
+              )
+            end
+
+            def aws_credentials(config)
+              if config.aws_access_key_id && config.aws_secret_access_key
+                Aws::Credentials.new(
+                  config.aws_access_key_id,
+                  config.aws_secret_access_key
+                )
+              else
+                # Use default credential chain
+                nil
+              end
+            end
+
+            def extract_text_from_response(response)
+              lines = response.blocks
+                .select { |b| b.block_type == "LINE" }
+                .sort_by { |b| [b.geometry.bounding_box.top, b.geometry.bounding_box.left] }
+                .map(&:text)
+
+              lines.join("\n")
+            end
+
+            def wait_for_job(client, job_id, max_attempts: 30, delay: 5)
+              attempts = 0
+
+              loop do
+                response = client.get_document_text_detection(job_id:)
+
+                case response.job_status
+                when "SUCCEEDED"
+                  return collect_all_pages(client, job_id)
+                when "FAILED"
+                  Rails.logger.error("[Aven::Textract] Job failed: #{response.status_message}")
+                  return nil
+                when "IN_PROGRESS"
+                  attempts += 1
+                  if attempts >= max_attempts
+                    Rails.logger.error("[Aven::Textract] Job timed out")
+                    return nil
+                  end
+                  sleep(delay)
+                end
+              end
+            end
+
+            def collect_all_pages(client, job_id)
+              all_text = []
+              next_token = nil
+
+              loop do
+                params = { job_id: }
+                params[:next_token] = next_token if next_token
+
+                response = client.get_document_text_detection(params)
+                all_text << extract_text_from_response(response)
+
+                next_token = response.next_token
+                break unless next_token
+              end
+
+              all_text.join("\n\n")
+            end
+        end
+      end
+    end
+  end
+end

data/app/services/aven/agentic/ocr/word_extractor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Aven
+  module Agentic
+    module Ocr
+      class WordExtractor < BaseExtractor
+        class << self
+          def extract(document)
+            with_tempfile(document) do |path|
+              extract_docx(path)
+            end
+          end
+
+          private
+
+            def extract_docx(path)
+              # Use docx gem if available
+              if defined?(Docx::Document)
+                doc = Docx::Document.open(path)
+                paragraphs = doc.paragraphs.map(&:text)
+                paragraphs.join("\n\n")
+              else
+                Rails.logger.warn("[Aven::OCR] docx gem not available")
+                nil
+              end
+            rescue => e
+              Rails.logger.error("[Aven::OCR] Word extraction failed: #{e.message}")
+              nil
+            end
+        end
+      end
+    end
+  end
+end