ragdoll 0.1.0 → 0.1.1

data/lib/ragdoll.rb

@@ -1,12 +1,249 @@
-# This file is the main entry point for the Ragdoll gem, requiring all necessary components.
-
 # frozen_string_literal: true
 
-# frozen_string_literal: true
+require "debug_me"
+include DebugMe
+$DEBUG_ME = true
 
-require "ragdoll/version"
-require "ragdoll/engine"
+require "delegate"
+require_relative "ragdoll/core"
 
 module Ragdoll
-  class Error < StandardError; end
+  class << self
+
+    #################
+    # Configuration #
+    #################
+
+    # Retrieve the current configuration.
+    # @example
+    #   config = Ragdoll.config
+    #   puts config.database_config[:adapter]
+    # @example
+    #   current_config = Ragdoll.configuration
+    #   puts current_config.models[:default]
+    # @return [Ragdoll::Core::Configuration] the current configuration instance.
+    def config
+      Core.config
+    end
+
+    # Configure the Ragdoll module.
+    # @yieldparam config [Ragdoll::Core::Configuration] the configuration instance to modify.
+    # @example
+    #   Ragdoll.configure do |config|
+    #     config.database_config[:adapter] = "postgres"
+    #   end
+    # @yield [Ragdoll::Core::Configuration] yields the configuration instance for modification.
+    def configure(*args, **kwargs, &block)
+      Ragdoll::Core.configure(*args, **kwargs, &block)
+    end
+
+    # Access the current configuration.
+    # @param args [Array] additional arguments for configuration.
+    # @param kwargs [Hash] keyword arguments for configuration.
+    # @return [Ragdoll::Core::Configuration] the current configuration instance.
+    def configuration(*args, **kwargs)
+      Ragdoll::Core.configuration(*args, **kwargs)
+    end
+
+    # @example
+    #   Ragdoll.reset_configuration!
+    #   puts Ragdoll.config.models[:default]
+    def reset_configuration!(*args, **kwargs)
+      Ragdoll::Core.reset_configuration!(*args, **kwargs)
+    end
+
+
+    #######################
+    # Document Management #
+    #######################
+
+    # Add a directory of documents to the system.
+    # @param path [String] the path to the directory containing documents.
+    # @example
+    #   Ragdoll.add_directory(path: "/path/to/documents", recursive: true)
+    # @param recursive [Boolean] whether to add documents from subdirectories.
+    def add_directory(*args, **kwargs)
+      Ragdoll::Core.add_directory(*args, **kwargs)
+    end
+
+    # Add a single document to the system.
+    # @example
+    #   Ragdoll.add_document(path: "/path/to/document.txt")
+    # @param path [String] the file path of the document to add.
+    def add_document(*args, **kwargs)
+      Ragdoll::Core.add_document(*args, **kwargs)
+    end
+    alias_method :add, :add_document
+
+    # Retrieve a document by its identifier.
+    # @param id [String] the identifier of the document to retrieve.
+    # @example
+    #   document = Ragdoll.get_document(id: "123")
+    #   puts document[:title] if document
+    # @return [Hash, nil] the document data or nil if not found.
+    def get_document(*args, **kwargs)
+      Ragdoll::Core.get_document(*args, **kwargs)
+    end
+    alias_method :get, :get_document
+
+    # List all documents in the system.
+    # @param options [Hash] options for listing documents, such as limit and offset.
+    # @example
+    #   documents = Ragdoll.list_documents(limit: 10)
+    #   documents.each { |doc| puts doc[:title] }
+    # @return [Array<Hash>] an array of document data.
+    def list_documents(*args, **kwargs)
+      Ragdoll::Core.list_documents(*args, **kwargs)
+    end
+    alias_method :list, :list_documents
+
+    # Delete a document by its identifier.
+    # @param id [String] the identifier of the document to delete.
+    # @example
+    #   success = Ragdoll.delete_document(id: "123")
+    #   puts "Deleted" if success
+    # @return [Boolean] true if the document was successfully deleted.
+    def delete_document(*args, **kwargs)
+      Ragdoll::Core.delete_document(*args, **kwargs)
+    end
+    alias_method :delete, :delete_document
+
+    # Get the status of a document.
+    # @param id [String] the identifier of the document to check status.
+    # @example
+    #   status = Ragdoll.document_status(id: "123")
+    #   puts status[:status]
+    # @return [Hash] the status information of the document.
+    def document_status(*args, **kwargs)
+      Ragdoll::Core.document_status(*args, **kwargs)
+    end
+    alias_method :status, :document_status
+
+    # Update a document's information.
+    # @param id [String] the identifier of the document to update.
+    # @param updates [Hash] the fields to update in the document.
+    # @example
+    #   updated_doc = Ragdoll.update_document(id: "123", title: "New Title")
+    #   puts updated_doc[:title]
+    # @return [Hash] the updated document data.
+    def update_document(*args, **kwargs)
+      Ragdoll::Core.update_document(*args, **kwargs)
+    end
+    alias_method :update, :update_document
+
+    # Retrieve all documents.
+    # @example
+    #   all_docs = Ragdoll.documents
+    #   all_docs.each { |doc| puts doc.title }
+    # @return [ActiveRecord::Relation] a relation of all documents.
+    def documents
+      Ragdoll::Core::Models::Document.all
+    end
+    alias_method :docs, :documents
+
+    #############
+    # Retrieval #
+    #############
+
+    # FIXME: This high-level API method should be able to take a query that is
+    #        a string or a file.  If its a file, then the downstream Process will
+    #        be responsible for reading the file and passing the contents to the
+    #        search method based upon whether the content is text, image or audio.
+
+    # Perform a search for documents based on a query.
+    # @param query [String] the search query string.
+    # @param options [Hash] additional search options, such as filters and limits.
+    # @example
+    #   response = Ragdoll.search(query: "example search")
+    #   response[:results].each { |result| puts result[:document_title] }
+    # @return [Hash] the search results.
+    def search(*args, **kwargs)
+      Ragdoll::Core.search(*args, **kwargs)
+    end
+
+    # Enhance a prompt with additional context.
+    # @param prompt [String] the original prompt to enhance.
+    # @param context_limit [Integer] the number of context chunks to include.
+    # @param options [Hash] additional options for enhancing the prompt.
+    # @example
+    #   enhanced = Ragdoll.enhance_prompt(prompt: "What is AI?", context_limit: 3)
+    #   puts enhanced[:enhanced_prompt]
+    # @return [Hash] the enhanced prompt data.
+    def enhance_prompt(*args, **kwargs)
+      Ragdoll::Core.enhance_prompt(*args, **kwargs)
+    end
+
+    # Retrieve context for a given query.
+    # @param query [String] the query to retrieve context for.
+    # @param limit [Integer] the number of context chunks to retrieve.
+    # @param options [Hash] additional options for context retrieval.
+    # @example
+    #   context = Ragdoll.get_context(query: "AI", limit: 5)
+    #   puts context[:combined_context]
+    # @return [Hash] the context data.
+    def get_context(*args, **kwargs)
+      Ragdoll::Core.get_context(*args, **kwargs)
+    end
+
+    # Search for content similar to a given query.
+    # @param query [String] the query to find similar content for.
+    # @param options [Hash] additional options for the search, such as filters and limits.
+    # @example
+    #   similar_content = Ragdoll.search_similar_content(query: "AI")
+    #   similar_content.each { |content| puts content[:document_title] }
+    # @return [Array<Hash>] an array of similar content data.
+    def search_similar_content(*args, **kwargs)
+      Ragdoll::Core.search_similar_content(*args, **kwargs)
+    end
+
+
+    ###############
+    # Misc. Stuff #
+    ###############
+
+    # Retrieve statistics about the system.
+    # @example
+    #   stats = Ragdoll.stats
+    #   puts stats[:total_documents]
+    # @return [Hash] the system statistics.
+    def stats(*args, **kwargs)
+      Ragdoll::Core.stats(*args, **kwargs)
+    end
+
+    # Check if the system is healthy.
+    # @example
+    #   puts "System is healthy" if Ragdoll.healthy?
+    # @return [Boolean] true if the system is healthy.
+    def healthy?(*args, **kwargs)
+      Ragdoll::Core.healthy?(*args, **kwargs)
+    end
+
+    # Retrieve the client instance.
+    # @example
+    #   client = Ragdoll.client
+    #   puts client.inspect
+    # @return [Ragdoll::Core::Client] the client instance.
+    def client(*args, **kwargs)
+      Ragdoll::Core.client(*args, **kwargs)
+    end
+
+    # Retrieve the version information of the Ragdoll modules.
+    # @example
+    #   versions = Ragdoll.version
+    #   versions.each { |version| puts version }
+    # @return [Array<String>] an array of version strings for each module.
+    def version
+      versions = []
+
+      ObjectSpace.each_object(Module) do |mod|
+        if mod.name =~ /^Ragdoll::\w+$/
+          if defined?(mod::VERSION) && mod::VERSION.is_a?(String)
+            versions << "#{mod.name}: #{mod::VERSION}"
+          end
+        end
+      end
+
+      versions
+    end
+  end
 end

data/lib/tasks/annotate.rake

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "annotate"
+require "annotate/annotate_models"
+
+# Define environment task for gem context
+task :environment do
+  # Load the gem's environment
+  require_relative "../ragdoll-core"
+
+  # Set up database connection
+  begin
+    # Load all models to ensure they're available
+    Dir[File.join(__dir__, "../ragdoll/core/models/*.rb")].each { |file| require file }
+
+    # Set up database connection with default config
+    Ragdoll::Core::Database.setup({
+                                    adapter: "postgresql",
+                                    database: "ragdoll_development",
+                                    username: "ragdoll",
+                                    password: ENV["RAGDOLL_DATABASE_PASSWORD"] || ENV["DATABASE_PASSWORD"],
+                                    host: "localhost",
+                                    port: 5432,
+                                    auto_migrate: false # Don't auto-migrate during annotation
+                                  })
+
+    puts "✅ Connected to database: ragdoll_development"
+  rescue StandardError => e
+    puts "❌ Database connection failed: #{e.message}"
+    puts "   Annotations will be based on model definitions only"
+  end
+end
+
+namespace :annotate do
+  task :models do
+    AnnotateModels.do_annotations({
+                                    "models" => "true",
+                                    "position_in_class" => "before",
+                                    "show_foreign_keys" => "true",
+                                    "show_indexes" => "true",
+                                    "model_dir" => "lib/ragdoll/core/models",
+                                    "exclude_tests" => "true",
+                                    "exclude_fixtures" => "true",
+                                    "exclude_factories" => "true",
+                                    "exclude_serializers" => "true",
+                                    "exclude_scaffolds" => "true",
+                                    "exclude_controllers" => "true",
+                                    "exclude_helpers" => "true"
+                                  })
+  end
+end
+
+task :set_annotation_options do
+  # You can override any of these by setting an environment variable of the
+  # same name.
+  Annotate.set_defaults(
+    "active_admin" => "false",
+    "additional_file_patterns" => [],
+    "routes" => "false",
+    "models" => "true",
+    "position_in_routes" => "before",
+    "position_in_class" => "before",
+    "position_in_test" => "before",
+    "position_in_fixture" => "before",
+    "position_in_factory" => "before",
+    "position_in_serializer" => "before",
+    "show_foreign_keys" => "true",
+    "show_complete_foreign_keys" => "false",
+    "show_indexes" => "true",
+    "simple_indexes" => "false",
+    "model_dir" => "lib/ragdoll/core/models",
+    "root_dir" => "",
+    "include_version" => "false",
+    "require" => "",
+    "exclude_tests" => "false",
+    "exclude_fixtures" => "false",
+    "exclude_factories" => "false",
+    "exclude_serializers" => "false",
+    "exclude_scaffolds" => "false",
+    "exclude_controllers" => "true",
+    "exclude_helpers" => "true",
+    "exclude_sti_subclasses" => "false",
+    "ignore_model_sub_dir" => "false",
+    "ignore_columns" => nil,
+    "ignore_routes" => nil,
+    "ignore_unknown_options" => "false",
+    "hide_limit_column_types" => "integer,bigint,boolean",
+    "hide_default_column_types" => "json,jsonb,hstore",
+    "skip_on_db_migrate" => "false",
+    "format_bare" => "true",
+    "format_rdoc" => "false",
+    "format_yard" => "false",
+    "format_markdown" => "false",
+    "sort" => "false",
+    "force" => "false",
+    "frozen" => "false",
+    "classified_sort" => "true",
+    "trace" => "false",
+    "wrapper_open" => nil,
+    "wrapper_close" => nil,
+    "with_comment" => "true"
+  )
+end
+
+# Load only essential model annotation tasks
+desc "Add schema information (as comments) to model files"
+task annotate_models: :environment do
+  puts "Running annotate for ragdoll-core models..."
+
+  # Use the CLI approach since the programmatic API doesn't respect model_dir properly
+  success = system("MODEL_DIR=lib/ragdoll/core/models bundle exec annotate --models --position-in-class=before --show-foreign-keys --show-indexes")
+
+  if success
+    puts "✅ Model annotations updated successfully!"
+  else
+    puts "⚠️  Annotate completed with warnings (database connection issues)"
+  end
+end
+
+desc "Remove schema information from model files"
+task :remove_annotation do
+  AnnotateModels.remove_annotations({
+                                      "models" => "true",
+                                      "model_dir" => "lib/ragdoll/core/models"
+                                    })
+end