polylingo_chat 0.1.0

data/lib/generators/polylingo_chat/install/templates/initializer.rb

@@ -0,0 +1,24 @@
+PolylingoChat.configure do |config|
+  # API key for AI translation service
+  # Leave nil to use chat-only mode (no translation)
+  config.api_key = nil
+
+  # AI provider: :openai, :anthropic, or :gemini
+  config.provider = :anthropic
+
+  # Model to use for translation
+  # OpenAI: 'gpt-4-turbo' or 'gpt-3.5-turbo'
+  # Anthropic: 'claude-3-5-sonnet-20241022' or 'claude-3-haiku-20240307'
+  # Gemini: 'gemini-1.5-pro' or 'gemini-1.5-flash'
+  config.model = 'claude-3-5-sonnet-20241022'
+
+  # Default language for users without a preferred language
+  config.default_language = 'en'
+
+  # Enable async job processing (requires ActiveJob)
+  config.async = true
+
+  # Queue adapter (e.g., :solid_queue, :sidekiq, :async)
+  # Set to match your app's ActiveJob queue adapter
+  # config.queue_adapter = :solid_queue
+end

data/lib/generators/polylingo_chat/install/templates/javascript/channels/consumer.js

@@ -0,0 +1,15 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the `bin/rails generate channel` command.
+
+import { createConsumer } from "@rails/actioncable"
+
+// Pass user_id as a query parameter for authentication
+const getWebSocketURL = () => {
+  const userId = window.currentUserId
+  if (userId) {
+    return `/cable?user_id=${userId}`
+  }
+  return "/cable"
+}
+
+export default createConsumer(getWebSocketURL())

data/lib/generators/polylingo_chat/install/templates/javascript/channels/index.js

@@ -0,0 +1,2 @@
+// Import all the channels to be used by Action Cable
+import "./consumer"

data/lib/generators/polylingo_chat/install/templates/javascript/chat.js

@@ -0,0 +1,86 @@
+import consumer from "channels/consumer"
+
+console.log("Chat.js loaded!")
+
+document.addEventListener('turbo:load', () => {
+  console.log("Turbo loaded!")
+
+  const conversationId = window.conversationId
+  const currentUserId = window.currentUserId
+
+  console.log("Conversation ID:", conversationId)
+  console.log("Current User ID:", currentUserId)
+
+  if (!conversationId) {
+    console.log("No conversation ID found, skipping ActionCable subscription")
+    return
+  }
+
+  // Subscribe to the PolylinguoChatChannel
+  console.log("Subscribing to PolylinguoChatChannel...")
+  const subscription = consumer.subscriptions.create(
+    { channel: "PolylinguoChatChannel", conversation_id: conversationId },
+    {
+      connected() {
+        console.log("✓ Connected to PolylinguoChatChannel!")
+      },
+
+      disconnected() {
+        console.log("✗ Disconnected from PolylinguoChatChannel")
+      },
+
+      received(data) {
+        console.log("✓ Received message:", data)
+
+        const messagesContainer = document.getElementById('messages')
+        if (!messagesContainer) return
+
+        // Check if message already exists in DOM (prevent duplicates)
+        const existingMessage = messagesContainer.querySelector(`[data-message-id="${data.message_id}"]`)
+        if (existingMessage) {
+          console.log("Message already exists, skipping:", data.message_id)
+          return
+        }
+
+        // Add new message
+        const messageHtml = createMessageElement(data)
+        messagesContainer.insertAdjacentHTML('beforeend', messageHtml)
+
+        // Auto-scroll to bottom
+        messagesContainer.scrollTop = messagesContainer.scrollHeight
+      }
+    }
+  )
+
+  // Auto-scroll messages to bottom on page load
+  const messagesContainer = document.getElementById('messages')
+  if (messagesContainer) {
+    messagesContainer.scrollTop = messagesContainer.scrollHeight
+  }
+
+  function createMessageElement(data) {
+    const isCurrentUser = data.sender_id === currentUserId
+    const alignment = isCurrentUser ? 'justify-end' : 'justify-start'
+    const bgColor = isCurrentUser ? 'bg-blue-500 text-white' : 'bg-gray-200 text-gray-800'
+
+    const translatedBadge = data.translated ? '<p class="text-xs mt-1 opacity-75">✓ Translated</p>' : ''
+    const time = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })
+
+    return `
+      <div class="message flex ${alignment}" data-message-id="${data.message_id}">
+        <div class="${bgColor} rounded-lg px-4 py-2 max-w-xs">
+          <p class="text-xs font-semibold mb-1">${escapeHtml(data.sender_name || 'Unknown')}</p>
+          <p class="text-sm">${escapeHtml(data.message)}</p>
+          ${translatedBadge}
+          <p class="text-xs mt-1 opacity-75">${time}</p>
+        </div>
+      </div>
+    `
+  }
+
+  function escapeHtml(text) {
+    const div = document.createElement('div')
+    div.textContent = text
+    return div.innerHTML
+  }
+})

data/lib/generators/polylingo_chat/install/templates/models/conversation.rb

@@ -0,0 +1,7 @@
+class Conversation < ApplicationRecord
+  has_many :participants, dependent: :destroy
+  has_many :users, through: :participants
+  has_many :messages, dependent: :destroy
+
+  validates :title, length: { maximum: 255 }, allow_blank: true
+end

data/lib/generators/polylingo_chat/install/templates/models/message.rb

@@ -0,0 +1,14 @@
+class Message < ApplicationRecord
+  belongs_to :conversation
+  belongs_to :sender, class_name: 'User', foreign_key: 'sender_id'
+
+  validates :body, presence: true
+
+  after_create_commit :enqueue_translation_job
+
+  private
+
+  def enqueue_translation_job
+    PolylingoChat::TranslateJob.perform_later(id) if PolylingoChat.config.async
+  end
+end

data/lib/generators/polylingo_chat/install/templates/models/participant.rb

@@ -0,0 +1,6 @@
+class Participant < ApplicationRecord
+  belongs_to :user
+  belongs_to :conversation
+
+  validates :user_id, uniqueness: { scope: :conversation_id }
+end

data/lib/generators/polylingo_chat/install_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators'
+module PolylingoChat
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def copy_initializer
+        template 'polylingo_chat.rb', 'config/initializers/polylingo_chat.rb'
+      end
+
+      def copy_channel
+        template 'polylingo_chat_chat_channel.rb', 'app/channels/polylingo_chat_chat_channel.rb'
+      end
+
+      def copy_js_example
+        template 'chat_channel_example.js', 'app/javascript/channels/polylingo_chat_chat_channel.js'
+      end
+
+      def copy_models
+        template 'models/conversation.rb', 'app/models/conversation.rb'
+        template 'models/participant.rb',  'app/models/participant.rb'
+        template 'models/message.rb',      'app/models/message.rb'
+      end
+
+      def copy_migrations
+        migration_template 'create_polylingo_chat_conversations.rb', 'db/migrate/create_polylingo_chat_conversations.rb'
+        migration_template 'create_polylingo_chat_participants.rb',  'db/migrate/create_polylingo_chat_participants.rb'
+        migration_template 'create_polylingo_chat_messages.rb',      'db/migrate/create_polylingo_chat_messages.rb'
+      rescue => e
+        say_status('warning', 'Skipping migrations: ensure you add your own Message/Conversation models or run generator again with --migrate', :yellow)
+      end
+
+      def show_readme
+        readme 'INSTALL_README.md' if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/polylingo_chat/templates/INSTALL_README.md

@@ -0,0 +1,124 @@
+## PolylingoChat Installation Complete!
+
+### Next Steps:
+
+**PolylingoChat can work in TWO modes:**
+1. **Chat-Only Mode:** Real-time chat without translation (no API key needed)
+2. **With Translation:** AI-powered translation (API key required)
+
+---
+
+### 1. Run migrations
+```bash
+bin/rails db:migrate
+```
+
+### 2. Configure ActiveJob
+
+```ruby
+# config/application.rb or config/environments/production.rb
+config.active_job.queue_adapter = :sidekiq  # or :solid_queue, :delayed_job, :async
+```
+
+### 3. Install your background job processor
+
+**Sidekiq:**
+```ruby
+# Gemfile
+gem 'sidekiq'
+```
+Then: `bundle install && bundle exec sidekiq`
+
+**Solid Queue:**
+```ruby
+# Gemfile
+gem 'solid_queue'
+```
+Then: `bundle install && bin/rails solid_queue:install && bin/rails db:migrate && bin/rails solid_queue:start`
+
+**Delayed Job:**
+```ruby
+# Gemfile
+gem 'delayed_job_active_record'
+```
+Then: `bundle install && bin/rails generate delayed_job:active_record && bin/rails db:migrate && bin/rails jobs:work`
+
+---
+
+### 4. Configure PolylingoChat
+
+Edit `config/initializers/polylingo_chat.rb`:
+
+**Option A: Chat-Only (No Translation)**
+```ruby
+PolylingoChat.configure do |config|
+  # Leave api_key as nil for chat-only mode
+  config.api_key = nil
+  config.queue_adapter = :sidekiq
+  config.async = true
+end
+```
+
+**Option B: With AI Translation**
+```ruby
+PolylingoChat.configure do |config|
+  # Enable translation
+  config.provider = :openai  # or :anthropic, :gemini
+  config.api_key = ENV['POLYGLOT_API_KEY']
+  config.model = 'gpt-4o-mini'
+
+  config.queue_adapter = :sidekiq
+  config.default_language = 'en'
+  config.cache_store = Rails.cache
+end
+```
+
+---
+
+### 5. (Optional) Add preferred_language to User
+
+**Only needed if using translation:**
+```bash
+bin/rails generate migration AddPreferredLanguageToUsers preferred_language:string
+bin/rails db:migrate
+```
+
+---
+
+### 6. Get API Key (Optional)
+
+**Only if you want translation:**
+- OpenAI: https://platform.openai.com/api-keys
+- Anthropic: https://console.anthropic.com/
+- Gemini: https://ai.google.dev/
+
+```bash
+# .env
+POLYGLOT_API_KEY=your-key-here
+```
+
+---
+
+### Testing
+
+```ruby
+conversation = Conversation.create!(title: "Test")
+Participant.create!(conversation: conversation, user: user1)
+Participant.create!(conversation: conversation, user: user2)
+
+Message.create!(
+  conversation: conversation,
+  sender: user1,
+  body: "Hello!"
+)
+```
+
+- **Without API key:** Message sent as-is
+- **With API key:** Message translated to each user's language
+
+---
+
+### Need Help?
+
+- 📖 Documentation: https://github.com/shoaibmalik786/polylingo_chat
+- 🐛 Issues: https://github.com/shoaibmalik786/polylingo_chat/issues

data/lib/generators/polylingo_chat/templates/chat_channel_example.js

@@ -0,0 +1,18 @@
+import consumer from "@rails/actioncable"
+
+const cable = consumer.createConsumer();
+
+export default function subscribe(conversationId, handleReceive) {
+  const subscription = cable.subscriptions.create({ channel: 'PolylinguoChatChannel', conversation_id: conversationId }, {
+    connected() {},
+    disconnected() {},
+    received(data) {
+      handleReceive(data)
+    },
+    sendMessage(text, conversationId) {
+      this.perform('receive', { message: text, conversation_id: conversationId });
+    }
+  });
+
+  return subscription;
+}

data/lib/generators/polylingo_chat/templates/create_polyglot_conversations.rb

@@ -0,0 +1,9 @@
+class CreatePolylingoChatConversations < ActiveRecord::Migration[6.0]
+  def change
+    create_table :conversations do |t|
+      t.string :title
+      t.boolean :private, default: true
+      t.timestamps
+    end
+  end
+end

data/lib/generators/polylingo_chat/templates/create_polyglot_messages.rb

@@ -0,0 +1,13 @@
+class CreatePolylingoChatMessages < ActiveRecord::Migration[6.0]
+  def change
+    create_table :messages do |t|
+      t.references :sender, null: false, foreign_key: { to_table: :users }
+      t.references :conversation, null: false, foreign_key: true
+      t.text :body
+      t.string :language
+      t.text :translated_body
+      t.boolean :translated, default: false
+      t.timestamps
+    end
+  end
+end

data/lib/generators/polylingo_chat/templates/create_polyglot_participants.rb

@@ -0,0 +1,12 @@
+class CreatePolylingoChatParticipants < ActiveRecord::Migration[6.0]
+  def change
+    create_table :participants do |t|
+      t.references :user, null: false, foreign_key: true
+      t.references :conversation, null: false, foreign_key: true
+      t.string :role
+      t.timestamps
+    end
+
+    add_index :participants, [:user_id, :conversation_id], unique: true
+  end
+end

data/lib/generators/polylingo_chat/templates/models/conversation.rb

@@ -0,0 +1,7 @@
+class Conversation < ApplicationRecord
+  has_many :participants, dependent: :destroy
+  has_many :users, through: :participants
+  has_many :messages, dependent: :destroy
+
+  validates :title, length: { maximum: 255 }, allow_blank: true
+end

data/lib/generators/polylingo_chat/templates/models/message.rb

@@ -0,0 +1,14 @@
+class Message < ApplicationRecord
+  belongs_to :conversation
+  belongs_to :sender, class_name: 'User', foreign_key: 'sender_id'
+
+  validates :body, presence: true
+
+  after_create_commit :enqueue_translation_job
+
+  private
+
+  def enqueue_translation_job
+    PolylingoChat::TranslateJob.perform_later(id) if PolylingoChat.config.async
+  end
+end

data/lib/generators/polylingo_chat/templates/models/participant.rb

@@ -0,0 +1,6 @@
+class Participant < ApplicationRecord
+  belongs_to :user
+  belongs_to :conversation
+
+  validates :user_id, uniqueness: { scope: :conversation_id }
+end

data/lib/generators/polylingo_chat/templates/polyglot.rb

@@ -0,0 +1,53 @@
+# PolylingoChat Configuration
+# For more information, see: https://github.com/shoaibmalik786/polylingo_chat
+
+PolylingoChat.configure do |config|
+  # ========================================
+  # AI Provider Configuration (OPTIONAL)
+  # ========================================
+
+  # Translation is OPTIONAL! If you don't set an API key, PolylingoChat works as a
+  # real-time chat engine without translation (messages sent as-is).
+
+  # To enable translation, choose your AI provider: :openai, :anthropic, or :gemini
+  config.provider = :openai
+
+  # Set your API key (leave nil to use chat-only mode without translation)
+  config.api_key = ENV['POLYGLOT_API_KEY']  # or set to nil for chat-only mode
+
+  # Choose your model based on provider:
+  # OpenAI: 'gpt-4o-mini', 'gpt-4o', 'gpt-3.5-turbo'
+  # Anthropic: 'claude-3-5-sonnet-20241022', 'claude-3-5-haiku-20241022', 'claude-3-opus-20240229'
+  # Gemini: 'gemini-1.5-flash', 'gemini-1.5-pro'
+  config.model = 'gpt-4o-mini'
+
+  # ========================================
+  # Background Job Configuration
+  # ========================================
+
+  # Specify which ActiveJob adapter you're using (OPTIONAL, for documentation purposes)
+  # You still need to configure ActiveJob in your Rails app as normal
+  # Options: :sidekiq, :solid_queue, :delayed_job, :async, :inline, etc.
+  #
+  # Example ActiveJob configuration (in config/application.rb or config/environments/*.rb):
+  #   config.active_job.queue_adapter = :sidekiq
+  #
+  # Then tell PolylingoChat which adapter you're using:
+  config.queue_adapter = :sidekiq  # Change this to match your ActiveJob setup
+
+  # Enable/disable async processing
+  config.async = true
+
+  # ========================================
+  # Translation Configuration
+  # ========================================
+
+  # Default language for translations (ISO 639-1 code)
+  config.default_language = 'en'
+
+  # Enable caching for translations (recommended for production)
+  config.cache_store = Rails.cache
+
+  # Request timeout in seconds
+  config.timeout = 15
+end

data/lib/generators/polylingo_chat/templates/polylingo_chat_channel.rb

@@ -0,0 +1,19 @@
+class PolylinguoChatChannel < ApplicationCable::Channel
+  def subscribed
+    # stream for the current user
+    stream_from "polylingo_chat_recipient_#{current_user.id}"
+  end
+
+  def receive(data)
+    # data: { message: 'Hola', conversation_id: 1 }
+    message_text = data['message']
+    conversation = Conversation.find(data['conversation_id'])
+
+    msg = Message.create!(conversation: conversation, sender: current_user, body: message_text, language: current_user.preferred_language)
+    # enqueue translation job
+    PolylingoChat::TranslateJob.perform_async(msg.id)
+
+    # broadcast original to sender's stream if you want
+    ActionCable.server.broadcast("polylingo_chat_recipient_#{current_user.id}", { message: message_text, original: message_text, sender_id: current_user.id, message_id: msg.id, original:true })
+  end
+end

data/lib/polylingo_chat/config.rb

@@ -0,0 +1,26 @@
+module PolylingoChat
+  class Config
+    attr_accessor :provider, :api_key, :model, :default_language, :cache_store, :async, :timeout, :queue_adapter
+
+    def initialize
+      @provider = :openai
+      @api_key = ENV['POLYGLOT_API_KEY']
+      @model = 'gpt-4o-mini'
+      @default_language = 'en'
+      @cache_store = nil
+      @async = true
+      @timeout = 15
+      @queue_adapter = nil # Optional: Specify which ActiveJob adapter you're using
+    end
+  end
+
+  def self.configure
+    @config ||= Config.new
+    yield @config if block_given?
+    @config
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+end

data/lib/polylingo_chat/engine.rb

@@ -0,0 +1,10 @@
+require 'rails/engine'
+module PolylingoChat
+  class Engine < ::Rails::Engine
+    isolate_namespace PolylingoChat
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/polylingo_chat/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails/railtie'
+
+module PolylingoChat
+  class Railtie < Rails::Railtie
+    # PolylingoChat Railtie - currently just for initialization hooks
+    # The queue_adapter config is informational - users configure ActiveJob themselves
+
+    initializer 'polylingo_chat.log_configuration', after: :load_config_initializers do
+      if PolylingoChat.config.queue_adapter
+        Rails.logger.info "PolylingoChat: Using #{PolylingoChat.config.queue_adapter} for background jobs"
+      end
+    end
+  end
+end

data/lib/polylingo_chat/realtime.rb

@@ -0,0 +1,8 @@
+module PolylingoChat
+  module Realtime
+    def self.channel_template
+      # returns a string of the channel implementation for host app generator
+      File.read(File.expand_path('../../templates/polylingo_chat_chat_channel.rb', __dir__))
+    end
+  end
+end

data/lib/polylingo_chat/translate_job.rb

@@ -0,0 +1,63 @@
+module PolylingoChat
+  class TranslateJob < ActiveJob::Base
+    queue_as :polylingo_chat_translations
+
+    def perform(message_id)
+      # Host app must implement Message model with associations matching spec
+      message = ::Message.find_by(id: message_id)
+      return unless message
+
+      conversation = message.conversation
+      return unless conversation
+
+      recipients = conversation.users.where.not(id: message.sender_id)
+
+      # Check if translation is enabled (API key present)
+      translation_enabled = PolylingoChat.config.api_key.present?
+
+      recipients.each do |recipient|
+        if translation_enabled
+          # Translation enabled - translate message
+          target_lang = recipient.preferred_language || PolylingoChat.config.default_language
+          source_lang = PolylingoChat::Translator.detect_language(message.body)
+          context = conversation.messages.order(created_at: :asc).last(20).pluck(:body).join("") rescue nil
+
+          translated = PolylingoChat::Translator.translate(text: message.body, from: source_lang, to: target_lang, context: context)
+          # If translator returns a Future-like, wait
+          translated = translated.value if translated.respond_to?(:value)
+        else
+          # No API key - just use original message (chat-only mode)
+          translated = message.body
+        end
+
+        # Broadcast to recipient using ActionCable
+        begin
+          # Broadcast to user-specific channel
+          ActionCable.server.broadcast("polylingo_chat_recipient_#{recipient.id}", {
+            message: translated,
+            original: message.body,
+            message_id: message.id,
+            sender_id: message.sender_id,
+            sender_name: message.sender.name,
+            translated: translation_enabled
+          })
+
+          # Also broadcast to conversation channel for demo/group chat
+          ActionCable.server.broadcast("conversation_#{conversation.id}", {
+            message: translated,
+            original: message.body,
+            message_id: message.id,
+            sender_id: message.sender_id,
+            sender_name: message.sender.name,
+            translated: translation_enabled,
+            recipient_id: recipient.id
+          })
+        rescue => e
+          # ignore broadcast errors
+        end
+      end
+
+      message.update(translated: translation_enabled) rescue nil
+    end
+  end
+end