geminize 0.1.0

data/lib/geminize/rails/app/controllers/concerns/geminize/controller.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Geminize
+  # Controller concern for including Gemini functionality in Rails controllers
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      # Helper methods for controllers using Geminize
+      helper_method :current_gemini_conversation if respond_to?(:helper_method)
+    end
+
+    # Current conversation for this controller context
+    # Uses session to maintain conversation state between requests
+    # @return [Geminize::Models::Conversation]
+    def current_gemini_conversation
+      return @current_gemini_conversation if defined?(@current_gemini_conversation)
+
+      if session[:gemini_conversation_id]
+        # Try to load existing conversation
+        begin
+          @current_gemini_conversation = Geminize.load_conversation(session[:gemini_conversation_id])
+        rescue => e
+          Rails.logger.error("Failed to load Gemini conversation: #{e.message}")
+          # Create a new conversation if loading fails
+          create_new_gemini_conversation
+        end
+      else
+        # Create a new conversation if one doesn't exist
+        create_new_gemini_conversation
+      end
+
+      @current_gemini_conversation
+    end
+
+    # Send a message in the current conversation
+    # @param message [String] The message to send
+    # @param model_name [String, nil] Optional model name override
+    # @param params [Hash] Additional parameters for the message
+    # @return [Geminize::Models::ChatResponse] The response
+    def send_gemini_message(message, model_name = nil, params = {})
+      response = Geminize.chat(message, current_gemini_conversation, model_name, params)
+      Geminize.save_conversation(current_gemini_conversation)
+      response
+    end
+
+    # Generate text using Gemini
+    # @param prompt [String] The prompt to send
+    # @param model_name [String, nil] Optional model name override
+    # @param params [Hash] Additional parameters for generation
+    # @return [Geminize::Models::ContentResponse] The response
+    def generate_gemini_text(prompt, model_name = nil, params = {})
+      Geminize.generate_text(prompt, model_name, params)
+    end
+
+    # Generate text with images using Gemini
+    # @param prompt [String] The prompt to send
+    # @param images [Array<Hash>] Array of image data
+    # @param model_name [String, nil] Optional model name override
+    # @param params [Hash] Additional parameters for generation
+    # @return [Geminize::Models::ContentResponse] The response
+    def generate_gemini_multimodal(prompt, images, model_name = nil, params = {})
+      Geminize.generate_text_multimodal(prompt, images, model_name, params)
+    end
+
+    # Generate embeddings for text using Gemini
+    # @param text [String, Array<String>] The text to embed
+    # @param model_name [String, nil] Optional model name override
+    # @param params [Hash] Additional parameters for embedding
+    # @return [Geminize::Models::EmbeddingResponse] The embedding response
+    def generate_gemini_embedding(text, model_name = nil, params = {})
+      Geminize.generate_embedding(text, model_name, params)
+    end
+
+    # Start a new conversation and store its ID in the session
+    # @param title [String, nil] Optional title for the conversation
+    # @param system_instruction [String, nil] Optional system instruction to guide model behavior
+    # @return [Geminize::Models::Conversation] The new conversation
+    def reset_gemini_conversation(title = nil, system_instruction = nil)
+      create_new_gemini_conversation(title, system_instruction)
+    end
+
+    # Set the system instruction for the current conversation
+    # @param system_instruction [String] The system instruction to set
+    # @return [Geminize::Models::Conversation] The updated conversation
+    def set_gemini_system_instruction(system_instruction)
+      current_gemini_conversation.system_instruction = system_instruction
+      Geminize.save_conversation(current_gemini_conversation)
+      current_gemini_conversation
+    end
+
+    private
+
+    # Create a new conversation and store its ID in the session
+    # @param title [String, nil] Optional title for the conversation
+    # @param system_instruction [String, nil] Optional system instruction to guide model behavior
+    # @return [Geminize::Models::Conversation] The new conversation
+    def create_new_gemini_conversation(title = nil, system_instruction = nil)
+      @current_gemini_conversation = Geminize.create_chat(title, system_instruction)
+      session[:gemini_conversation_id] = @current_gemini_conversation.id
+      Geminize.save_conversation(@current_gemini_conversation)
+      @current_gemini_conversation
+    end
+  end
+end

data/lib/geminize/rails/app/helpers/geminize_helper.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module GeminizeHelper
+  # Render the Gemini conversation as HTML
+  # @param conversation [Geminize::Models::Conversation, nil] Conversation to render (defaults to current_gemini_conversation)
+  # @param options [Hash] Optional rendering options
+  # @option options [String] :user_class CSS class for user messages
+  # @option options [String] :ai_class CSS class for AI messages
+  # @option options [Boolean] :include_timestamps Include message timestamps
+  # @return [String] HTML representation of the conversation
+  def render_gemini_conversation(conversation = nil, options = {})
+    conversation ||= current_gemini_conversation if respond_to?(:current_gemini_conversation)
+    return content_tag(:div, "No conversation available", class: "gemini-empty-conversation") unless conversation
+
+    content_tag(:div, class: "gemini-conversation") do
+      conversation.messages.map do |message|
+        render_gemini_message(message, options)
+      end.join.html_safe
+    end
+  end
+
+  # Render a single message from the conversation
+  # @param message [Geminize::Models::Message] The message to render
+  # @param options [Hash] Optional rendering options
+  # @return [String] HTML representation of the message
+  def render_gemini_message(message, options = {})
+    is_user = message.role == "user"
+
+    message_class = if is_user
+      options[:user_class] || "gemini-user-message"
+    else
+      options[:ai_class] || "gemini-ai-message"
+    end
+
+    content_tag(:div, class: "gemini-message #{message_class}") do
+      output = []
+
+      # Add the role label
+      output << content_tag(:div, is_user ? "You" : "AI", class: "gemini-message-role")
+
+      # Add the message content (convert newlines to <br> tags)
+      output << content_tag(:div, simple_format(message.parts.first["text"]), class: "gemini-message-content")
+
+      # Add timestamp if requested
+      if options[:include_timestamps] && message.respond_to?(:timestamp) && message.timestamp
+        timestamp = message.timestamp.is_a?(Time) ? message.timestamp : Time.parse(message.timestamp.to_s)
+        output << content_tag(:div, timestamp.strftime("%Y-%m-%d %H:%M:%S"), class: "gemini-message-timestamp")
+      end
+
+      output.join.html_safe
+    end
+  end
+
+  # Create a chat form that handles submitting messages to Gemini
+  # @param options [Hash] Form options
+  # @option options [String] :submit_text Text for the submit button (default: "Send")
+  # @option options [String] :placeholder Placeholder text (default: "Type your message...")
+  # @option options [String] :form_class CSS class for the form
+  # @option options [String] :input_class CSS class for the input field
+  # @option options [String] :submit_class CSS class for the submit button
+  # @option options [String] :url URL to submit the form to (default: current URL)
+  # @return [String] HTML form
+  def gemini_chat_form(options = {})
+    default_options = {
+      submit_text: "Send",
+      placeholder: "Type your message...",
+      form_class: "gemini-chat-form",
+      input_class: "gemini-chat-input",
+      submit_class: "gemini-chat-submit",
+      url: request.path
+    }
+
+    opts = default_options.merge(options)
+
+    form_tag(opts[:url], method: :post, class: opts[:form_class]) do
+      output = []
+      output << text_area_tag(:message, nil, placeholder: opts[:placeholder], class: opts[:input_class])
+      output << submit_tag(opts[:submit_text], class: opts[:submit_class])
+      output.join.html_safe
+    end
+  end
+
+  # Render Markdown text as HTML
+  # @param text [String] Markdown text to render
+  # @param options [Hash] Options for rendering
+  # @return [String] HTML content
+  def markdown_to_html(text, options = {})
+    return "" if text.blank?
+
+    # Check if the markdown gem is available
+    if defined?(Redcarpet)
+      renderer = Redcarpet::Render::HTML.new(hard_wrap: true, filter_html: false)
+      markdown = Redcarpet::Markdown.new(renderer, options)
+      markdown.render(text).html_safe
+    else
+      # Fall back to simple formatting if Redcarpet is not available
+      simple_format(text)
+    end
+  end
+
+  # Add syntax highlighting to code blocks
+  # @param html [String] HTML content that may contain code blocks
+  # @return [String] HTML with syntax highlighting applied
+  def highlight_code(html)
+    return html unless defined?(Rouge)
+
+    formatter = Rouge::Formatters::HTML.new
+
+    # Find all code blocks and apply syntax highlighting
+    doc = Nokogiri::HTML::DocumentFragment.parse(html)
+    doc.css("pre code").each do |code|
+      lang = code["class"]&.sub("language-", "") || "text"
+      lexer = Rouge::Lexer.find(lang) || Rouge::Lexers::PlainText.new
+
+      # Get the code content and format it
+      code_text = code.text
+      highlighted = formatter.format(lexer.lex(code_text))
+
+      # Replace the original code block with the highlighted version
+      code.parent.replace("<pre class=\"highlight #{lang}\">#{highlighted}</pre>")
+    end
+
+    doc.to_html.html_safe
+  end
+end

data/lib/geminize/rails/controller_additions.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Rails
+    # Module for adding Geminize functionality to controllers
+    # Provides methods that make it easy to include Geminize controller concerns.
+    #
+    # This module is automatically included in ActionController::Base
+    # when the gem is used in a Rails application.
+    #
+    # @example Including in a specific controller
+    #   class ChatController < ApplicationController
+    #     geminize_controller
+    #
+    #     def create
+    #       @response = send_gemini_message(params[:message])
+    #       render :show
+    #     end
+    #   end
+    module ControllerAdditions
+      # Add Geminize functionality to a controller
+      # This method includes the Geminize::Controller concern in your controller,
+      # which provides methods for working with the Gemini API.
+      #
+      # @return [void]
+      # @example
+      #   class ApplicationController < ActionController::Base
+      #     include Geminize::Rails::ControllerAdditions
+      #     geminize_controller
+      #   end
+      def geminize_controller
+        include Geminize::Controller
+      end
+    end
+  end
+end
+
+# Add the module to ActionController::Base if it exists
+ActiveSupport.on_load(:action_controller) do
+  include Geminize::Rails::ControllerAdditions
+end

data/lib/geminize/rails/engine.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Rails
+    # Rails engine for Geminize
+    # Provides Rails integration for the Gemini API.
+    class Engine < ::Rails::Engine
+      isolate_namespace Geminize
+
+      initializer "geminize.configure" do |app|
+        # Set up configuration if needed
+      end
+
+      initializer "geminize.load_concerns" do
+        ActiveSupport.on_load(:action_controller) do
+          require "geminize/rails/app/controllers/concerns/geminize/controller"
+        end
+
+        ActiveSupport.on_load(:action_view) do
+          require "geminize/rails/app/helpers/geminize_helper"
+        end
+      end
+
+      config.to_prepare do
+        # Load any dependencies that need to be available
+      end
+    end
+  end
+end

data/lib/geminize/rails/helper_additions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Geminize
+  module Rails
+    # Module for adding Geminize view helpers to Rails applications
+    # Provides methods to simplify the inclusion of Geminize helpers in views.
+    #
+    # This module is automatically included in ActionView::Base
+    # when the gem is used in a Rails application.
+    #
+    # @example Using Geminize helpers in a view
+    #   <%# After including the helpers in ApplicationHelper %>
+    #   <%= render_gemini_conversation %>
+    #   <%= gemini_chat_form %>
+    module HelperAdditions
+      # Add Geminize helpers to views
+      # This method includes the GeminizeHelper module in your view context,
+      # providing helper methods for rendering Gemini conversations, chat forms,
+      # and formatting responses.
+      #
+      # @return [void]
+      # @example
+      #   module ApplicationHelper
+      #     include Geminize::Rails::HelperAdditions
+      #     geminize_helper
+      #   end
+      def geminize_helper
+        include GeminizeHelper
+      end
+    end
+  end
+end
+
+# Add our helpers module to ActionView::Base if it exists
+ActiveSupport.on_load(:action_view) do
+  include Geminize::Rails::HelperAdditions
+end

data/lib/geminize/rails.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "geminize/rails/engine" if defined?(::Rails::Engine)
+require "geminize/railtie" if defined?(::Rails::Railtie)
+require "geminize/rails/controller_additions" if defined?(::ActionController::Base)
+require "geminize/rails/helper_additions" if defined?(::ActionView::Base)
+
+module Geminize
+  # Rails integration module for Geminize
+  # Provides Rails integration for the Google Gemini API.
+  #
+  # The integration includes:
+  # - A Rails engine to load all required components
+  # - Controller concerns with helper methods for Gemini operations
+  # - View helpers for rendering conversations and responses
+  # - Generators for creating configuration files
+  #
+  # @example Setting up in a Rails application
+  #   # In config/initializers/geminize.rb (created by the generator)
+  #   Geminize.configure do |config|
+  #     config.api_key = ENV.fetch("GEMINI_API_KEY")
+  #   end
+  #
+  #   # In app/controllers/chat_controller.rb
+  #   class ChatController < ApplicationController
+  #     geminize_controller
+  #
+  #     def create
+  #       @response = send_gemini_message(params[:message])
+  #       redirect_to chat_path
+  #     end
+  #   end
+  #
+  #   # In app/views/chat/show.html.erb
+  #   <%= render_gemini_conversation %>
+  #   <%= gemini_chat_form %>
+  module Rails
+    # Returns true if running in a Rails environment
+    # Useful for conditionally executing code only in Rails apps.
+    #
+    # @return [Boolean] true if Rails is defined
+    # @example
+    #   if Geminize::Rails.rails?
+    #     # Rails-specific code
+    #   end
+    def self.rails?
+      defined?(::Rails)
+    end
+  end
+end

data/lib/geminize/railtie.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Geminize
+  # Railtie for lightweight Rails integration
+  # Provides basic Rails integration when the full engine is not required.
+  # This is automatically loaded when the gem is used in a Rails application.
+  #
+  # @example Basic usage in a Rails application
+  #   # No additional setup needed - Railtie is loaded automatically
+  #   # In your controller:
+  #   class ExamplesController < ApplicationController
+  #     def example
+  #       @response = Geminize.generate_text("What is Ruby on Rails?").text
+  #     end
+  #   end
+  class Railtie < ::Rails::Railtie
+    # Configure Geminize when used in a Rails application
+    # @return [void]
+    initializer "geminize.configure" do |app|
+      # Set up configuration for Geminize when used in a Rails app
+      Geminize.configure do |config|
+        # Set conversations path to Rails tmp directory by default
+        config.conversations_path = Rails.root.join("tmp", "conversations") if config.conversations_path.nil?
+      end
+    end
+
+    # Set up any rake tasks if needed
+    # @return [void]
+    rake_tasks do
+      # Define rake tasks here if needed
+    end
+  end
+end

data/lib/geminize/request_builder.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Geminize
+  # Utility module for building requests to the Gemini API
+  module RequestBuilder
+    class << self
+      # Build a text generation request for the Gemini API
+      # @param content_request [Geminize::Models::ContentRequest] The content request
+      # @return [Hash] The complete request hash ready to send to the API
+      def build_text_generation_request(content_request)
+        model_name = content_request.model_name
+        Validators.validate_not_empty!(model_name, "Model name")
+
+        {
+          model: model_name,
+          **content_request.to_hash
+        }
+      end
+
+      # Build a chat request for the Gemini API
+      # @param chat_request [Geminize::Models::ChatRequest] The chat request
+      # @param message_history [Array<Hash>] The message history from the conversation
+      # @return [Hash] The complete request hash ready to send to the API
+      def build_chat_request(chat_request, message_history = [])
+        model_name = chat_request.model_name
+        Validators.validate_not_empty!(model_name, "Model name")
+
+        {
+          model: model_name,
+          **chat_request.to_hash(message_history)
+        }
+      end
+
+      # Build a complete API endpoint path for a model
+      # @param model_name [String] The name of the model
+      # @param action [String] The action to perform (e.g., "generateContent")
+      # @return [String] The complete API endpoint path
+      def build_model_endpoint(model_name, action)
+        "models/#{model_name}:#{action}"
+      end
+
+      # Build the text generation endpoint for a specific model
+      # @param model_name [String] The name of the model
+      # @return [String] The complete API endpoint path for text generation
+      def build_text_generation_endpoint(model_name)
+        build_model_endpoint(model_name, "generateContent")
+      end
+
+      # Build the streaming text generation endpoint for a specific model
+      # @param model_name [String] The name of the model
+      # @return [String] The complete API endpoint path for streaming text generation
+      def build_streaming_endpoint(model_name)
+        build_model_endpoint(model_name, "streamGenerateContent")
+      end
+    end
+  end
+end