rails_ai_promptable 0.1.0

data/lib/generators/rails_ai_promptable/install_generator.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module RailsAiPromptable
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      desc 'Creates a RailsAIPromptable initializer file'
+
+      class_option :provider,
+                   type: :string,
+                   default: 'openai',
+                   desc: 'AI provider to use (openai, anthropic, gemini, cohere, azure_openai, mistral, openrouter)'
+
+      def copy_initializer_file
+        template 'rails_ai_promptable.rb.tt', 'config/initializers/rails_ai_promptable.rb'
+      end
+
+      def show_readme
+        readme 'POST_INSTALL' if behavior == :invoke
+      end
+
+      private
+
+      def provider_name
+        options['provider'].to_s
+      end
+
+      def provider_config
+        case provider_name
+        when 'openai'
+          openai_config
+        when 'anthropic', 'claude'
+          anthropic_config
+        when 'gemini', 'google'
+          gemini_config
+        when 'cohere'
+          cohere_config
+        when 'azure_openai', 'azure'
+          azure_config
+        when 'mistral'
+          mistral_config
+        when 'openrouter'
+          openrouter_config
+        else
+          openai_config
+        end
+      end
+
+      def openai_config
+        {
+          provider: ':openai',
+          api_key: "ENV['OPENAI_API_KEY']",
+          default_model: "'gpt-4o-mini'",
+          additional_config: "  # config.openai_base_url = 'https://api.openai.com/v1' # Optional: custom endpoint"
+        }
+      end
+
+      def anthropic_config
+        {
+          provider: ':anthropic',
+          api_key: "ENV['ANTHROPIC_API_KEY']",
+          default_model: "'claude-3-5-sonnet-20241022'",
+          additional_config: "  # config.anthropic_base_url = 'https://api.anthropic.com/v1' # Optional: custom endpoint"
+        }
+      end
+
+      def gemini_config
+        {
+          provider: ':gemini',
+          api_key: "ENV['GEMINI_API_KEY']",
+          default_model: "'gemini-pro'",
+          additional_config: "  # config.gemini_base_url = 'https://generativelanguage.googleapis.com/v1beta' # Optional: custom endpoint"
+        }
+      end
+
+      def cohere_config
+        {
+          provider: ':cohere',
+          api_key: "ENV['COHERE_API_KEY']",
+          default_model: "'command'",
+          additional_config: "  # config.cohere_base_url = 'https://api.cohere.ai/v1' # Optional: custom endpoint"
+        }
+      end
+
+      def azure_config
+        {
+          provider: ':azure_openai',
+          api_key: "ENV['AZURE_OPENAI_API_KEY']",
+          default_model: "'gpt-4'",
+          additional_config: <<~CONFIG.chomp
+            config.azure_base_url = ENV['AZURE_OPENAI_BASE_URL'] # Required: e.g., https://your-resource.openai.azure.com
+              config.azure_deployment_name = ENV['AZURE_OPENAI_DEPLOYMENT_NAME'] # Required
+              # config.azure_api_version = '2024-02-15-preview' # Optional: API version
+          CONFIG
+        }
+      end
+
+      def mistral_config
+        {
+          provider: ':mistral',
+          api_key: "ENV['MISTRAL_API_KEY']",
+          default_model: "'mistral-small-latest'",
+          additional_config: "  # config.mistral_base_url = 'https://api.mistral.ai/v1' # Optional: custom endpoint"
+        }
+      end
+
+      def openrouter_config
+        {
+          provider: ':openrouter',
+          api_key: "ENV['OPENROUTER_API_KEY']",
+          default_model: "'openai/gpt-3.5-turbo'",
+          additional_config: <<~CONFIG.chomp
+            # config.openrouter_app_name = 'Your App Name' # Optional: for tracking
+              # config.openrouter_site_url = 'https://yourapp.com' # Optional: for attribution
+              # config.openrouter_base_url = 'https://openrouter.ai/api/v1' # Optional: custom endpoint
+          CONFIG
+        }
+      end
+    end
+  end
+end

data/lib/generators/rails_ai_promptable/templates/POST_INSTALL

@@ -0,0 +1,46 @@
+===============================================================================
+
+  RailsAIPromptable has been successfully installed!
+
+===============================================================================
+
+Next steps:
+
+  1. Set up your API key in your environment:
+
+     <%= provider_config[:api_key].include?('OPENAI') ? 'export OPENAI_API_KEY="your-api-key-here"' : '' %>
+     <%= provider_config[:api_key].include?('ANTHROPIC') ? 'export ANTHROPIC_API_KEY="your-api-key-here"' : '' %>
+     <%= provider_config[:api_key].include?('GEMINI') ? 'export GEMINI_API_KEY="your-api-key-here"' : '' %>
+     <%= provider_config[:api_key].include?('COHERE') ? 'export COHERE_API_KEY="your-api-key-here"' : '' %>
+     <%= provider_config[:api_key].include?('AZURE') ? 'export AZURE_OPENAI_API_KEY="your-api-key-here"' : '' %>
+     <%= provider_config[:api_key].include?('MISTRAL') ? 'export MISTRAL_API_KEY="your-api-key-here"' : '' %>
+     <%= provider_config[:api_key].include?('OPENROUTER') ? 'export OPENROUTER_API_KEY="your-api-key-here"' : '' %>
+
+  2. Review and customize the configuration in:
+     config/initializers/rails_ai_promptable.rb
+
+  3. Include RailsAIPromptable::Promptable in your models:
+
+     class Article < ApplicationRecord
+       include RailsAIPromptable::Promptable
+
+       prompt_template "Summarize this article: %{content}"
+
+       def generate_summary
+         ai_generate(context: { content: body })
+       end
+     end
+
+  4. Start generating AI content!
+
+     article = Article.first
+     summary = article.generate_summary
+
+===============================================================================
+
+For more information and examples:
+
+  • Documentation: https://github.com/shoaibmalik786/rails_ai_promptable
+  • Issues: https://github.com/shoaibmalik786/rails_ai_promptable/issues
+
+===============================================================================

data/lib/generators/rails_ai_promptable/templates/rails_ai_promptable.rb.tt

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# RailsAIPromptable Configuration
+#
+# This file was generated by rails_ai_promptable:install
+#
+# For more configuration options, see:
+# https://github.com/shoaibmalik786/rails_ai_promptable
+
+RailsAIPromptable.configure do |config|
+  # ==> Provider Configuration
+  # Choose your AI provider. Supported options:
+  # :openai, :anthropic, :gemini, :cohere, :azure_openai, :mistral, :openrouter
+  config.provider = <%= provider_config[:provider] %>
+
+  # ==> Authentication
+  # API key for the selected provider
+  config.api_key = <%= provider_config[:api_key] %>
+
+  # ==> Model Settings
+  # Default model to use for AI generation
+  config.default_model = <%= provider_config[:default_model] %>
+
+  # ==> General Settings
+  # HTTP timeout in seconds for API requests
+  config.timeout = 30
+
+  # Logger for debugging and monitoring
+  # config.logger = Rails.logger
+
+  # ==> Provider-Specific Configuration
+<%= provider_config[:additional_config] %>
+
+  # ==> Multiple Providers (Optional)
+  # You can configure multiple providers and switch between them at runtime
+  # Example:
+  # config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+  # config.gemini_api_key = ENV['GEMINI_API_KEY']
+  # config.cohere_api_key = ENV['COHERE_API_KEY']
+  # config.mistral_api_key = ENV['MISTRAL_API_KEY']
+  # config.openrouter_api_key = ENV['OPENROUTER_API_KEY']
+end

data/lib/rails_ai_promptable/background_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_job'
+rescue LoadError
+  # ActiveJob not available, skip loading BackgroundJob
+end
+
+if defined?(ActiveJob)
+  module RailsAIPromptable
+    class BackgroundJob < ActiveJob::Base
+      queue_as :default
+
+      def perform(klass_name, record_id, context, kwargs)
+        klass = klass_name.constantize
+        record = klass.find_by(id: record_id)
+        return unless record
+
+        result = record.ai_generate(context: context, **(kwargs || {}))
+
+        # Call the callback method if defined on the record
+        if record.respond_to?(:ai_generation_completed)
+          record.ai_generation_completed(result)
+        end
+
+        # Store result in ai_generated_content attribute if it exists
+        if record.respond_to?(:ai_generated_content=)
+          record.ai_generated_content = result
+          record.save if record.respond_to?(:save)
+        end
+
+        RailsAIPromptable.configuration.logger.info("[rails_ai_promptable] background generation completed for #{klass_name}##{record_id}")
+
+        result
+      end
+    end
+  end
+end

data/lib/rails_ai_promptable/configuration.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RailsAIPromptable
+  class Configuration
+    attr_accessor :provider, :api_key, :default_model, :timeout, :logger,
+                  # OpenAI
+                  :openai_base_url,
+                  # Anthropic/Claude
+                  :anthropic_api_key, :anthropic_base_url,
+                  # Google Gemini
+                  :gemini_api_key, :gemini_base_url,
+                  # Cohere
+                  :cohere_api_key, :cohere_base_url,
+                  # Azure OpenAI
+                  :azure_api_key, :azure_base_url, :azure_api_version, :azure_deployment_name,
+                  # Mistral AI
+                  :mistral_api_key, :mistral_base_url,
+                  # OpenRouter
+                  :openrouter_api_key, :openrouter_base_url, :openrouter_app_name, :openrouter_site_url
+
+    def initialize
+      @provider = :openai
+      @api_key = ENV['OPENAI_API_KEY']
+      @default_model = 'gpt-4o-mini'
+      @timeout = 30
+      @logger = Logger.new($stdout)
+
+      # OpenAI settings
+      @openai_base_url = 'https://api.openai.com/v1'
+
+      # Anthropic settings
+      @anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+      @anthropic_base_url = 'https://api.anthropic.com/v1'
+
+      # Gemini settings
+      @gemini_api_key = ENV['GEMINI_API_KEY']
+      @gemini_base_url = 'https://generativelanguage.googleapis.com/v1beta'
+
+      # Cohere settings
+      @cohere_api_key = ENV['COHERE_API_KEY']
+      @cohere_base_url = 'https://api.cohere.ai/v1'
+
+      # Azure OpenAI settings
+      @azure_api_key = ENV['AZURE_OPENAI_API_KEY']
+      @azure_base_url = ENV['AZURE_OPENAI_BASE_URL']
+      @azure_api_version = '2024-02-15-preview'
+      @azure_deployment_name = ENV['AZURE_OPENAI_DEPLOYMENT_NAME']
+
+      # Mistral AI settings
+      @mistral_api_key = ENV['MISTRAL_API_KEY']
+      @mistral_base_url = 'https://api.mistral.ai/v1'
+
+      # OpenRouter settings
+      @openrouter_api_key = ENV['OPENROUTER_API_KEY']
+      @openrouter_base_url = 'https://openrouter.ai/api/v1'
+      @openrouter_app_name = ENV['OPENROUTER_APP_NAME']
+      @openrouter_site_url = ENV['OPENROUTER_SITE_URL']
+    end
+
+    # Helper method to get the appropriate default model for the current provider
+    def model_for_provider
+      case provider.to_sym
+      when :openai
+        'gpt-4o-mini'
+      when :anthropic
+        'claude-3-5-sonnet-20241022'
+      when :gemini
+        'gemini-pro'
+      when :cohere
+        'command'
+      when :azure_openai
+        azure_deployment_name || 'gpt-4'
+      when :mistral
+        'mistral-small-latest'
+      when :openrouter
+        'openai/gpt-3.5-turbo'
+      else
+        default_model
+      end
+    end
+  end
+end

data/lib/rails_ai_promptable/logger.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'logger'
+
+module RailsAIPromptable
+  class Logger
+    def initialize(io = $stdout)
+      @logger = ::Logger.new(io)
+    end
+
+    def info(msg)
+      @logger.info(msg)
+    end
+
+    def error(msg)
+      @logger.error(msg)
+    end
+  end
+end

data/lib/rails_ai_promptable/promptable.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module RailsAIPromptable
+  module Promptable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :ai_prompt_template, instance_accessor: false
+    end
+
+    class_methods do
+      def prompt_template(template = nil)
+        return ai_prompt_template if template.nil?
+        self.ai_prompt_template = template
+      end
+
+      # Load a template from the template registry
+      def ai_use_template(name)
+        template = RailsAIPromptable::TemplateRegistry.get(name)
+
+        if template.nil?
+          raise ArgumentError, "Template '#{name}' not found. Available templates: #{RailsAIPromptable::TemplateRegistry.list.join(', ')}"
+        end
+
+        self.ai_prompt_template = template
+      end
+    end
+
+    def ai_generate(context: {}, model: nil, temperature: nil, format: :text)
+      template = self.class.ai_prompt_template || ''
+      prompt = render_template(template, context)
+
+      RailsAIPromptable.configuration.logger.info("[rails_ai_promptable] prompt: ")
+
+      response = RailsAIPromptable.client.generate(
+        prompt: prompt,
+        model: model || RailsAIPromptable.configuration.default_model,
+        temperature: temperature || 0.7,
+        format: format
+      )
+
+      # basic parsing
+      response
+    end
+
+    def ai_generate_later(context: {}, **kwargs)
+      RailsAIPromptable.configuration.logger.info('[rails_ai_promptable] enqueuing ai_generate_later')
+      # Use ActiveJob to enqueue. We'll provide a default job class in later steps.
+      RailsAIPromptable::BackgroundJob.perform_later(self.class.name, id, context, kwargs)
+    end
+
+    private
+
+    def render_template(template, context)
+      template % context.transform_keys(&:to_sym)
+    rescue KeyError
+      # fallback: simple interpolation using gsub
+      result = template.dup
+      context.each { |k, v| result.gsub!("%{#{k}}", v.to_s) }
+      result
+    end
+  end
+end

data/lib/rails_ai_promptable/providers/anthropic_provider.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module RailsAIPromptable
+  module Providers
+    class AnthropicProvider < BaseProvider
+      API_VERSION = '2023-06-01'
+
+      def initialize(configuration)
+        super
+        @api_key = configuration.anthropic_api_key || configuration.api_key
+        @base_url = configuration.anthropic_base_url || 'https://api.anthropic.com/v1'
+        @timeout = configuration.timeout
+      end
+
+      def generate(prompt:, model:, temperature:, format:)
+        uri = URI.parse("#{@base_url}/messages")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = @timeout
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+          'Content-Type' => 'application/json',
+          'x-api-key' => @api_key,
+          'anthropic-version' => API_VERSION
+        })
+
+        body = {
+          model: model,
+          messages: [{ role: 'user', content: prompt }],
+          temperature: temperature,
+          max_tokens: 4096
+        }
+
+        request.body = body.to_json
+
+        response = http.request(request)
+        parsed = JSON.parse(response.body)
+
+        if response.code.to_i >= 400
+          error_message = parsed.dig('error', 'message') || 'Unknown error'
+          raise "Anthropic API error: #{error_message}"
+        end
+
+        # Extract content from Anthropic response
+        parsed.dig('content', 0, 'text')
+      rescue => e
+        RailsAIPromptable.configuration.logger.error("[rails_ai_promptable] anthropic error: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/rails_ai_promptable/providers/azure_openai_provider.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module RailsAIPromptable
+  module Providers
+    class AzureOpenAIProvider < BaseProvider
+      def initialize(configuration)
+        super
+        @api_key = configuration.azure_api_key || configuration.api_key
+        @base_url = configuration.azure_base_url
+        @api_version = configuration.azure_api_version || '2024-02-15-preview'
+        @timeout = configuration.timeout
+        @deployment_name = configuration.azure_deployment_name
+
+        validate_azure_configuration!
+      end
+
+      def generate(prompt:, model:, temperature:, format:)
+        # Azure uses deployment name instead of model in the URL
+        deployment = @deployment_name || model
+        uri = URI.parse("#{@base_url}/openai/deployments/#{deployment}/chat/completions?api-version=#{@api_version}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = @timeout
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+          'Content-Type' => 'application/json',
+          'api-key' => @api_key
+        })
+
+        body = {
+          messages: [{ role: 'user', content: prompt }],
+          temperature: temperature,
+          max_tokens: 2048
+        }
+
+        request.body = body.to_json
+
+        response = http.request(request)
+        parsed = JSON.parse(response.body)
+
+        if response.code.to_i >= 400
+          error_message = parsed.dig('error', 'message') || 'Unknown error'
+          raise "Azure OpenAI API error: #{error_message}"
+        end
+
+        # Extract content (same structure as OpenAI)
+        parsed.dig('choices', 0, 'message', 'content')
+      rescue => e
+        RailsAIPromptable.configuration.logger.error("[rails_ai_promptable] azure_openai error: #{e.message}")
+        nil
+      end
+
+      private
+
+      def validate_azure_configuration!
+        unless @base_url
+          raise ArgumentError, 'Azure OpenAI requires azure_base_url to be set (e.g., https://your-resource.openai.azure.com)'
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_promptable/providers/base_provider.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RailsAIPromptable
+  module Providers
+    class BaseProvider
+      def initialize(configuration)
+        @config = configuration
+      end
+
+      def generate(prompt:, model:, temperature:, format:)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rails_ai_promptable/providers/cohere_provider.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module RailsAIPromptable
+  module Providers
+    class CohereProvider < BaseProvider
+      def initialize(configuration)
+        super
+        @api_key = configuration.cohere_api_key || configuration.api_key
+        @base_url = configuration.cohere_base_url || 'https://api.cohere.ai/v1'
+        @timeout = configuration.timeout
+      end
+
+      def generate(prompt:, model:, temperature:, format:)
+        uri = URI.parse("#{@base_url}/generate")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = @timeout
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{@api_key}"
+        })
+
+        body = {
+          model: model,
+          prompt: prompt,
+          temperature: temperature,
+          max_tokens: 2048
+        }
+
+        request.body = body.to_json
+
+        response = http.request(request)
+        parsed = JSON.parse(response.body)
+
+        if response.code.to_i >= 400
+          error_message = parsed['message'] || 'Unknown error'
+          raise "Cohere API error: #{error_message}"
+        end
+
+        # Extract content from Cohere response
+        parsed.dig('generations', 0, 'text')
+      rescue => e
+        RailsAIPromptable.configuration.logger.error("[rails_ai_promptable] cohere error: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/rails_ai_promptable/providers/gemini_provider.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module RailsAIPromptable
+  module Providers
+    class GeminiProvider < BaseProvider
+      def initialize(configuration)
+        super
+        @api_key = configuration.gemini_api_key || configuration.api_key
+        @base_url = configuration.gemini_base_url || 'https://generativelanguage.googleapis.com/v1beta'
+        @timeout = configuration.timeout
+      end
+
+      def generate(prompt:, model:, temperature:, format:)
+        # Gemini uses the API key as a query parameter
+        uri = URI.parse("#{@base_url}/models/#{model}:generateContent?key=#{@api_key}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = @timeout
+
+        request = Net::HTTP::Post.new(uri.request_uri, {
+          'Content-Type' => 'application/json'
+        })
+
+        body = {
+          contents: [{
+            parts: [{ text: prompt }]
+          }],
+          generationConfig: {
+            temperature: temperature,
+            maxOutputTokens: 2048
+          }
+        }
+
+        request.body = body.to_json
+
+        response = http.request(request)
+        parsed = JSON.parse(response.body)
+
+        if response.code.to_i >= 400
+          error_message = parsed.dig('error', 'message') || 'Unknown error'
+          raise "Gemini API error: #{error_message}"
+        end
+
+        # Extract content from Gemini response
+        parsed.dig('candidates', 0, 'content', 'parts', 0, 'text')
+      rescue => e
+        RailsAIPromptable.configuration.logger.error("[rails_ai_promptable] gemini error: #{e.message}")
+        nil
+      end
+    end
+  end
+end