contai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ea8b64ee261ac1e205aec107d9011fcb2a90194856143eb25c73a79af70f982
+  data.tar.gz: b91bd9e6138f0b4980ed0f2651f15083de0ae275524d3a749308f6af900c04b3
+SHA512:
+  metadata.gz: 596f44c2e09f5ada2af464d9f7f656569bc396a8b3343cf7415e53d89fa1a7c81457907995c263689468a8238df2dce43f871cd13ff7f26bef289ebd84c0ee30
+  data.tar.gz: da7f09f708f026f5bb5766d18a1d7e3125bd327fb0b2494a39e8575d6ffb9be51556896967dbec38ba0ce2d3e827efa419c2ac5893f237e6dcef8e11c522f63e

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-06-06
+
+- Initial release

data/README.md

@@ -0,0 +1,159 @@
+# Contai
+
+AI content generation for Rails models. Integrate external AI APIs seamlessly into your Rails applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'contai'
+```
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+### Basic Setup
+
+Include `Contai::Generatable` in your model and configure it:
+
+```ruby
+class Article < ApplicationRecord
+  include Contai::Generatable
+  
+  contai do
+    prompt_from :title, :description
+    output_to :body
+    provider :openai, api_key: ENV["OPENAI_API_KEY"]
+    template "Write a blog post about: {{title}} - {{description}}"
+  end
+end
+```
+
+### Generate Content
+
+```ruby
+article = Article.new(title: "Ruby on Rails", description: "Web framework")
+article.generate_ai_content!
+# Content will be generated and saved to article.body
+
+# Async generation
+article.generate_ai_content!(async: true)
+```
+### Supported Providers
+
+#### OpenAI
+```ruby
+provider :openai, 
+  api_key: ENV["OPENAI_API_KEY"],
+  model: "gpt-4",
+  max_tokens: 1000
+```
+
+#### Claude
+```ruby
+provider :claude,
+  api_key: ENV["CLAUDE_API_KEY"],
+  model: "claude-3-sonnet-20240229"
+```
+
+#### N8N Webhook
+```ruby
+provider :n8n,
+  webhook_url: "https://your-n8n-instance.com/webhook/your-webhook-id",
+  response_path: "output"
+```
+
+#### Custom HTTP
+```ruby
+provider :http,
+  url: "https://api.example.com/generate",
+  method: :post,
+  headers: { "Authorization" => "Bearer #{ENV['API_KEY']}" },
+  body_template: { prompt: "{{prompt}}", model_name: "custom-model" },
+  response_path: "result.text"
+```
+
+### Configuration
+
+Configure global defaults:
+
+```ruby
+# config/initializers/contai.rb
+Contai.configure do |config|
+  config.default_provider = :openai
+  config.default_template = "Generate content based on: {{prompt}}"
+  config.timeout = 30
+end
+```
+
+### Routes
+
+Add to your routes file:
+
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  post '/contai/generate', to: 'contai/generations#create', as: 'contai_generation'
+end
+```
+## Error Handling
+
+The gem provides comprehensive error handling:
+
+```ruby
+article = Article.new(title: "Test")
+result = article.generate_ai_content!
+
+unless result
+  puts article.errors.full_messages
+  # => ["AI generation failed: API error"]
+end
+```
+
+## Testing
+
+Test your models with Contai:
+
+```ruby
+# spec/models/article_spec.rb
+RSpec.describe Article do
+  describe '#generate_ai_content!' do
+    let(:article) { create(:article, title: "Test", description: "Test desc") }
+    
+    before do
+      allow_any_instance_of(Contai::Providers::OpenAI).to receive(:generate)
+        .and_return(double(success?: true, content: "Generated content"))
+    end
+    
+    it 'generates content' do
+      expect { article.generate_ai_content! }.to change { article.body }
+        .from(nil).to("Generated content")
+    end
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+rake spec
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [CAPAA License](https://capaal.com).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/app/controllers/contai/generations_controller.rb

@@ -0,0 +1,25 @@
+module Contai
+    class GenerationsController < ApplicationController
+      def create
+        model_class = params[:model].constantize
+        record = model_class.find(params[:id])
+        
+        if record.generate_ai_content!
+          render json: { 
+            success: true, 
+            content: record.send(record.class.contai_config[:output_field])
+          }
+        else
+          render json: { 
+            success: false, 
+            errors: record.errors.full_messages 
+          }, status: 422
+        end
+      rescue => e
+        render json: { 
+          success: false, 
+          error: e.message 
+        }, status: 500
+      end
+    end
+  end

data/app/helpers/contai_helper.rb

@@ -0,0 +1,39 @@
+module ContaiHelper
+    def contai_button(record, text: "Contai!", css_class: "btn btn-secondary contai-btn")
+      return unless record.class.respond_to?(:contai_config) && record.class.contai_config.any?
+      
+      button_to text, contai_generation_path, 
+                params: { model: record.class.name, id: record.id },
+                method: :post,
+                remote: true,
+                class: css_class,
+                data: { 
+                  contai_target: record.class.contai_config[:output_field],
+                  contai_record_id: record.id,
+                  contai_model: record.class.name
+                }
+    end
+  
+    def contai_field_with_button(form, field, options = {})
+      record = form.object
+      return form.text_area(field, options) unless record.class.respond_to?(:contai_config)
+      
+      config = record.class.contai_config
+      return form.text_area(field, options) unless config[:output_field] == field
+      
+      content_tag :div, class: "contai-field-wrapper" do
+        form.text_area(field, options.merge(
+          data: { contai_target: "output" }
+        )) +
+        content_tag(:button, "Contai!", 
+                    type: "button",
+                    class: "btn btn-secondary contai-generate-btn",
+                    data: {
+                      controller: "contai",
+                      contai_model_value: record.class.name,
+                      contai_record_id_value: record.id,
+                      contai_output_target: field
+                    })
+      end
+    end
+  end

data/app/jobs/contai_generation_job.rb

@@ -0,0 +1,7 @@
+class ContaiGenerationJob < ApplicationJob
+    queue_as :default
+  
+    def perform(record)
+      record.send(:perform_generation)
+    end
+  end

data/config/routes.rb

@@ -0,0 +1,3 @@
+# Rails.application.routes.draw do
+#   post '/contai/generate', to: 'contai/generations#create', as: 'contai_generation'
+# end

data/contai.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/contai/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "contai"
+  spec.version = Contai::VERSION
+  spec.authors = ["Panasenkov A."]
+  spec.email = ["apanasenkov@capaa.ru"]
+
+  spec.summary = "Gem for generating AI content for rails models"
+  spec.description = "A Ruby on Rails gem that provides seamless integration with AI services to automatically generate content for your Rails models. It offers a simple interface to enhance your models with AI-generated content, supporting various content types and customization options."
+  spec.homepage = "https://github.com/capaas/contai"
+  spec.license = "Unlicense"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/capaas/contai"
+  spec.metadata["changelog_uri"] = "https://github.com/capaas/contai/blob/main/CHANGELOG.md"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails", "~> 6.0"
+  spec.add_dependency "httparty", "~> 0.20"
+  
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "sqlite3", "~> 1.4"
+end

data/docs/usage.md

@@ -0,0 +1,70 @@
+# Contai Gem - Полное руководство по использованию
+
+## Быстрый старт
+
+### 1. Установка
+
+```ruby
+# Gemfile
+gem 'contai'
+```
+
+```bash
+bundle install
+rails generate contai:install
+```
+
+### 2. Настройка модели
+
+```ruby
+# app/models/article.rb
+class Article < ApplicationRecord
+  include Contai::Generatable
+  
+  contai do
+    prompt_from :title, :description
+    output_to :body
+    provider :openai, api_key: ENV['OPENAI_API_KEY']
+    template "Напиши подробную статью на тему: {{title}}. Описание: {{description}}"
+  end
+end
+```
+
+### 3. Использование в контроллере
+
+```ruby
+# app/controllers/articles_controller.rb
+class ArticlesController < ApplicationController
+  def create
+    @article = Article.new(article_params)
+    
+    if @article.save
+      # Синхронная генерация
+      @article.generate_ai_content!
+      
+      # Или асинхронная
+      # @article.generate_ai_content!(async: true)
+      
+      redirect_to @article
+    else
+      render :new
+    end
+  end
+  
+  def generate_content
+    @article = Article.find(params[:id])
+    
+    if @article.generate_ai_content!
+      redirect_to @article, notice: 'Контент успешно сгенерирован!'
+    else
+      redirect_to @article, alert: 'Ошибка генерации контента'
+    end
+  end
+  
+  private
+  
+  def article_params
+    params.require(:article).permit(:title, :description)
+  end
+end
+```

data/lib/contai/configuration.rb

@@ -0,0 +1,11 @@
+module Contai
+    class Configuration
+      attr_accessor :default_provider, :default_template, :timeout
+  
+      def initialize
+        @default_provider = :http
+        @default_template = "Generate content based on: {{prompt}}"
+        @timeout = 30
+      end
+    end
+  end

data/lib/contai/engine.rb

@@ -0,0 +1,9 @@
+module Contai
+    class Engine < ::Rails::Engine
+      isolate_namespace Contai
+  
+      initializer "contai.assets" do |app|
+        app.config.assets.precompile += %w[contai.js contai.css]
+      end
+    end
+  end

data/lib/contai/generatabale.rb

@@ -0,0 +1,102 @@
+module Contai
+    module Generatable
+      extend ActiveSupport::Concern
+  
+      included do
+        class_attribute :contai_config, default: {}
+      end
+  
+      class_methods do
+        def contai(&block)
+          config = ContaiConfig.new
+          config.instance_eval(&block) if block_given?
+          self.contai_config = config.to_h
+        end
+      end
+  
+      def generate_ai_content!(async: false)
+        if async
+          ContaiGenerationJob.perform_later(self)
+        else
+          perform_generation
+        end
+      end
+  
+      private
+  
+      def perform_generation
+        config = self.class.contai_config
+        return false if config.empty?
+  
+        prompt = build_prompt(config)
+        provider = Providers.build(config[:provider], config[:provider_options])
+        
+        result = provider.generate(prompt)
+        
+        if result.success?
+          update!(config[:output_field] => result.content)
+          true
+        else
+          errors.add(:base, "AI generation failed: #{result.error}")
+          false
+        end
+      rescue => e
+        errors.add(:base, "AI generation error: #{e.message}")
+        false
+      end
+  
+      def build_prompt(config)
+        template = config[:template] || Contai.configuration.default_template
+        data = {}
+        
+        config[:prompt_fields].each do |field|
+          data[field] = send(field)
+        end
+        
+        # Simple template substitution
+        template.gsub(/\{\{(\w+)\}\}/) do |match|
+          field = $1.to_sym
+          data[field] || match
+        end
+      end
+    end
+  
+    class ContaiConfig
+      attr_accessor :prompt_fields, :output_field, :provider_type, :provider_options, :template
+  
+      def initialize
+        @prompt_fields = [:prompt]
+        @output_field = :body
+        @provider_type = :http
+        @provider_options = {}
+        @template = nil
+      end
+  
+      def prompt_from(*fields)
+        @prompt_fields = fields
+      end
+  
+      def output_to(field)
+        @output_field = field
+      end
+  
+      def provider(type, options = {})
+        @provider_type = type
+        @provider_options = options
+      end
+  
+      def template(tmpl)
+        @template = tmpl
+      end
+  
+      def to_h
+        {
+          prompt_fields: @prompt_fields,
+          output_field: @output_field,
+          provider: @provider_type,
+          provider_options: @provider_options,
+          template: @template
+        }
+      end
+    end
+  end

data/lib/contai/providers/base.rb

@@ -0,0 +1,37 @@
+module Contai
+    module Providers
+      class Base
+        def initialize(options = {})
+          @options = options
+        end
+  
+        def generate(prompt)
+          raise NotImplementedError, "Subclasses must implement #generate"
+        end
+  
+        protected
+  
+        def success_result(content)
+          Result.new(success: true, content: content)
+        end
+  
+        def error_result(error)
+          Result.new(success: false, error: error)
+        end
+  
+        class Result
+          attr_reader :content, :error
+  
+          def initialize(success:, content: nil, error: nil)
+            @success = success
+            @content = content
+            @error = error
+          end
+  
+          def success?
+            @success
+          end
+        end
+      end
+    end
+  end

data/lib/contai/providers/claude.rb

@@ -0,0 +1,38 @@
+require "httparty"
+
+module Contai
+  module Providers
+    class Claude < Base
+      include HTTParty
+      
+      base_uri "https://api.anthropic.com/v1"
+
+      def generate(prompt)
+        response = self.class.post("/messages",
+          headers: {
+            "x-api-key" => @options[:api_key],
+            "Content-Type" => "application/json",
+            "anthropic-version" => "2023-06-01"
+          },
+          body: {
+            model: @options[:model] || "claude-3-sonnet-20240229",
+            max_tokens: @options[:max_tokens] || 1000,
+            messages: [
+              { role: "user", content: prompt }
+            ]
+          }.to_json,
+          timeout: @options[:timeout] || Contai.configuration.timeout
+        )
+
+        if response.success?
+          content = response.parsed_response.dig("content", 0, "text")
+          success_result(content)
+        else
+          error_result("Claude API error: #{response.code} #{response.message}")
+        end
+      rescue => e
+        error_result(e.message)
+      end
+    end
+  end
+end

data/lib/contai/providers/http.rb

@@ -0,0 +1,57 @@
+require "httparty"
+
+module Contai
+  module Providers
+    class HTTP < Base
+      include HTTParty
+
+      def generate(prompt)
+        url = @options[:url] || raise(ArgumentError, "HTTP provider requires :url option")
+        method = (@options[:method] || :post).to_s.downcase
+        
+        request_options = {
+          headers: @options[:headers] || { "Content-Type" => "application/json" },
+          timeout: @options[:timeout] || Contai.configuration.timeout
+        }
+
+        body_data = @options[:body_template] || { prompt: prompt }
+        if body_data.is_a?(Hash)
+          body_data = body_data.transform_values { |v| v.is_a?(String) ? v.gsub("{{prompt}}", prompt) : v }
+          request_options[:body] = body_data.to_json
+        end
+
+        response = case method
+                  when "get"
+                    self.class.get(url, request_options)
+                  when "post"
+                    self.class.post(url, request_options)
+                  when "put"
+                    self.class.put(url, request_options)
+                  else
+                    raise ArgumentError, "Unsupported HTTP method: #{method}"
+                  end
+
+        if response.success?
+          content = extract_content(response, @options[:response_path])
+          success_result(content)
+        else
+          error_result("HTTP API error: #{response.code} #{response.message}")
+        end
+      rescue => e
+        error_result(e.message)
+      end
+
+      private
+
+      def extract_content(response, path)
+        return response.parsed_response.to_s unless path
+
+        content = response.parsed_response
+        path.split(".").each do |key|
+          content = content[key] if content.respond_to?(:[])
+        end
+        content.to_s
+      end
+    end
+  end
+end

data/lib/contai/providers/n8n.rb

@@ -0,0 +1,17 @@
+module Contai
+    module Providers
+      class N8N < HTTP
+        def initialize(options = {})
+          webhook_url = options[:webhook_url] || raise(ArgumentError, "N8N provider requires :webhook_url")
+          
+          super({
+            url: webhook_url,
+            method: :post,
+            headers: { "Content-Type" => "application/json" },
+            body_template: { prompt: "{{prompt}}" },
+            response_path: options[:response_path] || "output"
+          }.merge(options))
+        end
+      end
+    end
+  end

data/lib/contai/providers/openai.rb

@@ -0,0 +1,37 @@
+require "httparty"
+
+module Contai
+  module Providers
+    class OpenAI < Base
+      include HTTParty
+      
+      base_uri "https://api.openai.com/v1"
+
+      def generate(prompt)
+        response = self.class.post("/chat/completions",
+          headers: {
+            "Authorization" => "Bearer #{@options[:api_key]}",
+            "Content-Type" => "application/json"
+          },
+          body: {
+            model: @options[:model] || "gpt-3.5-turbo",
+            messages: [
+              { role: "user", content: prompt }
+            ],
+            max_tokens: @options[:max_tokens] || 1000
+          }.to_json,
+          timeout: @options[:timeout] || Contai.configuration.timeout
+        )
+
+        if response.success?
+          content = response.parsed_response.dig("choices", 0, "message", "content")
+          success_result(content)
+        else
+          error_result("OpenAI API error: #{response.code} #{response.message}")
+        end
+      rescue => e
+        error_result(e.message)
+      end
+    end
+  end
+end

data/lib/contai/providers.rb

@@ -0,0 +1,24 @@
+require "contai/providers/base"
+require "contai/providers/openai"
+require "contai/providers/claude"
+require "contai/providers/http"
+require "contai/providers/n8n"
+
+module Contai
+  module Providers
+    def self.build(type, options = {})
+      case type.to_sym
+      when :openai
+        OpenAI.new(options)
+      when :claude
+        Claude.new(options)
+      when :n8n
+        N8N.new(options)
+      when :http
+        HTTP.new(options)
+      else
+        raise ArgumentError, "Unknown provider: #{type}"
+      end
+    end
+  end
+end

data/lib/contai/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Contai
+  VERSION = "0.1.0"
+end

data/lib/contai.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "contai/version"
+require "contai/configuration"
+require "contai/generatable"
+require "contai/providers"
+require "contai/engine" if defined?(Rails)
+
+module Contai
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/generators/contai/install_generator.rb

@@ -0,0 +1,68 @@
+module Contai
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+  
+        desc "Install Contai into your Rails application"
+  
+        def create_initializer
+          template 'initializer.rb', 'config/initializers/contai.rb'
+        end
+  
+        def add_routes
+          route 'post "/contai/generate", to: "contai/generations#create", as: "contai_generation"'
+        end
+  
+        def create_stimulus_controller
+          if stimulus_detected?
+            template 'contai_controller.js', 'app/javascript/controllers/contai_controller.js'
+            
+            say "Stimulus controller created. Make sure to register it in your application:", :green
+            say "// app/javascript/controllers/application.js"
+            say 'import ContaiController from "./contai_controller"'
+            say 'application.register("contai", ContaiController)'
+          end
+        end
+  
+        def copy_assets
+          template 'contai.js', 'app/assets/javascripts/contai.js'
+          template 'contai.css', 'app/assets/stylesheets/contai.css'
+        end
+  
+        def create_job
+          template 'contai_generation_job.rb', 'app/jobs/contai_generation_job.rb'
+        end
+  
+        def show_instructions
+          say "\n" + "="*60
+          say "Contai has been installed successfully!", :green
+          say "="*60
+          say "\nNext steps:"
+          say "1. Configure your AI providers in config/initializers/contai.rb"
+          say "2. Add 'include Contai::Generatable' to your models"
+          say "3. Configure your models with the contai DSL"
+          say "4. Use contai_button or contai_field_with_button helpers in your views"
+          say "\nExample model configuration:"
+          say <<~EXAMPLE
+            class Article < ApplicationRecord
+              include Contai::Generatable
+              
+              contai do
+                prompt_from :title, :description
+                output_to :body
+                provider :openai, api_key: ENV['OPENAI_API_KEY']
+                template "Write about: {{title}} - {{description}}"
+              end
+            end
+          EXAMPLE
+        end
+  
+        private
+  
+        def stimulus_detected?
+          File.exist?(Rails.root.join('app/javascript/controllers/application.js'))
+        end
+      end
+    end
+  end
+  

data/lib/generators/contai/model_generator.rb

@@ -0,0 +1,55 @@
+module Contai
+    module Generators
+      class ModelGenerator < Rails::Generators::NamedBase
+        source_root File.expand_path('templates', __dir__)
+  
+        desc "Add Contai configuration to an existing model"
+  
+        class_option :prompt_fields, type: :array, default: ['title'], 
+                     desc: "Fields to use for prompt generation"
+        class_option :output_field, type: :string, default: 'body',
+                     desc: "Field to store generated content"
+        class_option :provider, type: :string, default: 'openai',
+                     desc: "AI provider to use"
+        class_option :template, type: :string,
+                     desc: "Custom template for prompt generation"
+  
+        def add_contai_to_model
+          model_file = "app/models/#{file_name}.rb"
+          
+          unless File.exist?(model_file)
+            say "Model #{class_name} not found at #{model_file}", :red
+            return
+          end
+  
+          inject_into_class model_file, class_name do
+            contai_configuration
+          end
+  
+          say "Added Contai configuration to #{class_name}", :green
+        end
+  
+        private
+  
+        def contai_configuration
+          prompt_fields = options[:prompt_fields].map(&:to_sym)
+          output_field = options[:output_field].to_sym
+          provider = options[:provider].to_sym
+          template = options[:template]
+  
+          config = []
+          config << "  include Contai::Generatable"
+          config << ""
+          config << "  contai do"
+          config << "    prompt_from #{prompt_fields.map(&:inspect).join(', ')}"
+          config << "    output_to :#{output_field}"
+          config << "    provider :#{provider}"
+          config << "    template \"#{template}\"" if template
+          config << "  end"
+          config << ""
+  
+          config.join("\n")
+        end
+      end
+    end
+  end

data/lib/generators/contai/templates/contai.css

@@ -0,0 +1,53 @@
+.contai-field-wrapper {
+    position: relative;
+  }
+  
+  .contai-generate-btn {
+    margin-top: 5px;
+    font-size: 0.875rem;
+  }
+  
+  .contai-btn {
+    background-color: #6366f1;
+    border-color: #6366f1;
+    color: white;
+    padding: 0.375rem 0.75rem;
+    border-radius: 0.25rem;
+    border: 1px solid transparent;
+    font-size: 0.875rem;
+    line-height: 1.5;
+    cursor: pointer;
+    text-decoration: none;
+    display: inline-block;
+    text-align: center;
+    vertical-align: middle;
+    user-select: none;
+    transition: color 0.15s ease-in-out, background-color 0.15s ease-in-out, border-color 0.15s ease-in-out, box-shadow 0.15s ease-in-out;
+  }
+  
+  .contai-btn:hover {
+    background-color: #4f46e5;
+    border-color: #4f46e5;
+    color: white;
+  }
+  
+  .contai-btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
+  
+  .contai-notification {
+    animation: slideIn 0.3s ease-out;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+  }
+  
+  @keyframes slideIn {
+    from {
+      transform: translateX(100%);
+      opacity: 0;
+    }
+    to {
+      transform: translateX(0);
+      opacity: 1;
+    }
+  }

data/lib/generators/contai/templates/contai.js

@@ -0,0 +1,82 @@
+(() => {
+  'use strict';
+
+  document.addEventListener('click', (e) => {
+    const button = e.target.closest('[data-contai-model]');
+    if (!button) return;
+    
+    e.preventDefault();
+    
+    const model = button.dataset.contaiModel;
+    const recordId = button.dataset.contaiRecordId;
+    const outputTarget = button.dataset.contaiOutputTarget;
+    
+    generateContaiContent(button, model, recordId, outputTarget);
+  });
+
+  function generateContaiContent(button, model, recordId, outputTarget) {
+    const originalText = button.textContent;
+    
+    button.disabled = true;
+    button.textContent = 'Generating...';
+    
+    fetch('/contai/generate', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-CSRF-Token': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content')
+      },
+      body: JSON.stringify({
+        model: model,
+        id: recordId
+      })
+    })
+    .then(response => response.json())
+    .then(data => {
+      if (data.success) {
+        updateOutput(outputTarget, data.content);
+        showNotification('Content generated successfully!', 'success');
+      } else {
+        showNotification('Error: ' + (data.errors || data.error), 'error');
+      }
+    })
+    .catch(() => {
+      showNotification('Network error occurred', 'error');
+    })
+    .finally(() => {
+      button.disabled = false;
+      button.textContent = originalText;
+    });
+  }
+
+  function updateOutput(fieldName, content) {
+    const field = document.querySelector(`[name*="${fieldName}"]`);
+    if (field) {
+      field.value = content;
+      field.dispatchEvent(new Event('input'));
+    }
+  }
+
+  function showNotification(message, type) {
+    const notification = document.createElement('div');
+    notification.className = `contai-notification contai-${type}`;
+    notification.textContent = message;
+    
+    Object.assign(notification.style, {
+      position: 'fixed',
+      top: '20px',
+      right: '20px',
+      padding: '10px 15px',
+      borderRadius: '4px',
+      color: 'white',
+      zIndex: '1000',
+      backgroundColor: type === 'success' ? '#28a745' : '#dc3545'
+    });
+    
+    document.body.appendChild(notification);
+    
+    setTimeout(() => {
+      notification.remove();
+    }, 3000);
+  }
+})();

data/lib/generators/contai/templates/contai_controller.js

@@ -0,0 +1,109 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["output"]
+  static values = { 
+    model: String, 
+    recordId: Number,
+    outputTarget: String
+  }
+
+  connect() {
+    this.setupButton()
+  }
+
+  setupButton() {
+    const button = this.element.querySelector('.contai-generate-btn')
+    if (button) {
+      button.addEventListener('click', this.generate.bind(this))
+    }
+  }
+
+  async generate(event) {
+    event.preventDefault()
+    
+    const button = event.target
+    const originalText = button.textContent
+    
+    try {
+      button.disabled = true
+      button.textContent = 'Generating...'
+      
+      const response = await fetch('/contai/generate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-CSRF-Token': this.getCSRFToken()
+        },
+        body: JSON.stringify({
+          model: this.modelValue,
+          id: this.recordIdValue
+        })
+      })
+      
+      const data = await response.json()
+      
+      if (data.success) {
+        this.updateOutput(data.content)
+        this.showSuccess()
+      } else {
+        this.showError(data.errors || [data.error])
+      }
+    } catch (error) {
+      this.showError(['Network error occurred'])
+    } finally {
+      button.disabled = false
+      button.textContent = originalText
+    }
+  }
+
+  updateOutput(content) {
+    if (this.hasOutputTarget) {
+      this.outputTarget.value = content
+      this.outputTarget.dispatchEvent(new Event('input', { bubbles: true }))
+    } else {
+      const fieldName = this.outputTargetValue || 'body'
+      const field = this.element.querySelector(`[name*="${fieldName}"]`)
+      if (field) {
+        field.value = content
+        field.dispatchEvent(new Event('input', { bubbles: true }))
+      }
+    }
+  }
+
+  showSuccess() {
+    this.showNotification('Content generated successfully!', 'success')
+  }
+
+  showError(errors) {
+    const message = Array.isArray(errors) ? errors.join(', ') : errors
+    this.showNotification(`Error: ${message}`, 'error')
+  }
+
+  showNotification(message, type) {
+    const notification = document.createElement('div')
+    notification.className = `contai-notification contai-${type}`
+    notification.textContent = message
+    notification.style.cssText = `
+      position: fixed;
+      top: 20px;
+      right: 20px;
+      padding: 10px 15px;
+      border-radius: 4px;
+      color: white;
+      z-index: 1000;
+      background-color: ${type === 'success' ? '#28a745' : '#dc3545'};
+    `
+    
+    document.body.appendChild(notification)
+    
+    setTimeout(() => {
+      notification.remove()
+    }, 3000)
+  }
+
+  getCSRFToken() {
+    const token = document.querySelector('meta[name="csrf-token"]')
+    return token ? token.getAttribute('content') : ''
+  }
+}

data/lib/generators/contai/templates/contai_generation_job.rb

@@ -0,0 +1,7 @@
+class ContaiGenerationJob < ApplicationJob
+    queue_as :default
+  
+    def perform(record)
+      record.send(:perform_generation)
+    end
+  end

data/lib/generators/contai/templates/initializer.rb

@@ -0,0 +1,34 @@
+Contai.configure do |config|
+    # Default provider for all models (can be overridden per model)
+    config.default_provider = :http
+    
+    # Default template for prompt generation
+    config.default_template = "Generate content based on: {{prompt}}"
+    
+    # Request timeout in seconds
+    config.timeout = 30
+  end
+  
+  # Configure your AI providers here:
+  
+  # OpenAI Configuration
+  # Contai::Providers::OpenAI.configure do |config|
+  #   config.api_key = ENV['OPENAI_API_KEY']
+  #   config.default_model = 'gpt-3.5-turbo'
+  #   config.default_max_tokens = 1000
+  # end
+  
+  # Claude Configuration  
+  # Contai::Providers::Claude.configure do |config|
+  #   config.api_key = ENV['CLAUDE_API_KEY']
+  #   config.default_model = 'claude-3-sonnet-20240229'
+  # end
+  
+  # Custom HTTP API Configuration
+  # Contai::Providers::HTTP.configure do |config|
+  #   config.default_url = ENV['AI_API_URL']
+  #   config.default_headers = {
+  #     'Authorization' => "Bearer #{ENV['AI_API_KEY']}",
+  #     'Content-Type' => 'application/json'
+  #   }
+  # end

data/sig/contai.rbs

@@ -0,0 +1,4 @@
+module Contai
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: contai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Panasenkov A.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description: A Ruby on Rails gem that provides seamless integration with AI services
+  to automatically generate content for your Rails models. It offers a simple interface
+  to enhance your models with AI-generated content, supporting various content types
+  and customization options.
+email:
+- apanasenkov@capaa.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- README.md
+- Rakefile
+- app/controllers/contai/generations_controller.rb
+- app/helpers/contai_helper.rb
+- app/jobs/contai_generation_job.rb
+- config/routes.rb
+- contai.gemspec
+- docs/usage.md
+- lib/contai.rb
+- lib/contai/configuration.rb
+- lib/contai/engine.rb
+- lib/contai/generatabale.rb
+- lib/contai/providers.rb
+- lib/contai/providers/base.rb
+- lib/contai/providers/claude.rb
+- lib/contai/providers/http.rb
+- lib/contai/providers/n8n.rb
+- lib/contai/providers/openai.rb
+- lib/contai/version.rb
+- lib/generators/contai/install_generator.rb
+- lib/generators/contai/model_generator.rb
+- lib/generators/contai/templates/contai.css
+- lib/generators/contai/templates/contai.js
+- lib/generators/contai/templates/contai_controller.js
+- lib/generators/contai/templates/contai_generation_job.rb
+- lib/generators/contai/templates/initializer.rb
+- sig/contai.rbs
+homepage: https://github.com/capaas/contai
+licenses:
+- Unlicense
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/capaas/contai
+  source_code_uri: https://github.com/capaas/contai
+  changelog_uri: https://github.com/capaas/contai/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Gem for generating AI content for rails models
+test_files: []