blazer-ai 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5383dbf30daabea740fc3a6623310bd7d2c79bdc80e8a9ebb682f36b1660a52
-  data.tar.gz: cc47d89bc105c77af5ce838c09caa3cd9bded14e70710888284dfd1ba1fd1a20
+  metadata.gz: ae37ca646c57731bc74109540de81eba74164b71f4f057f98060c54127167848
+  data.tar.gz: 649ebd6b0667fa5a41035dabf3b94e8d077c9627c491f05e01642f67e8bf53fd
 SHA512:
-  metadata.gz: 1ebe828b2b7f50b44d1f63b9ec0595bcf972c0136ea79da9d0bd8072f696205cd43ab766ec487fbb369e96c544b9027c68b474fa4f70e06b193aad9a4718b891
-  data.tar.gz: 48a86302e19684549ef22cd19d9b60e9013c91128b489f073f48c508915c47f18471c8a7a6290c073babd0f10633d6ecc289cdb6e9603cdbd04e83189033a662
+  metadata.gz: a7d1f3812b5e8b159e6dab2782134587f8c23b3faf4797a95fbcff4f3e3af330bee39b8dfaec80a57d6e4eea00d8de9b896bc7c5c49dbc99da17d0293589f0fb
+  data.tar.gz: dc6ab6edd63c9f76dc498b2ebf55108b108729052ad136f291c722b5f248d95268f53e5878fdb4a23a52f0dd77d2fe4692266be999df4d2cc1d1b270c8d2862a

data/app/controllers/blazer/ai/queries_controller.rb

@@ -1,7 +1,7 @@
 # Handles AI-powered SQL generation requests.
 # Validates rate limits, sanitizes input, and returns generated SQL.
 class Blazer::Ai::QueriesController < Blazer::Ai::ApplicationController
-  before_action :ensure_ai_enabled, only: [ :create ]
+  before_action :ensure_ai_enabled, only: [:create]
 
   def create
     rate_limiter.check_and_track!(identifier: current_identifier)
@@ -12,17 +12,17 @@ class Blazer::Ai::QueriesController < Blazer::Ai::ApplicationController
     sql = generator.call
     log_generation(query_params, sql)
 
-    render json: { sql: sql }
+    render json: {sql: sql}
   rescue SqlValidator::ValidationError
-    render json: { error: "Generated SQL failed safety validation" }, status: :unprocessable_entity
+    render json: {error: "Generated SQL failed safety validation"}, status: :unprocessable_entity
   rescue SqlGenerator::GenerationError => e
-    render json: { error: e.message }, status: :unprocessable_entity
+    render json: {error: e.message}, status: :unprocessable_entity
   rescue RateLimiter::RateLimitExceeded => e
-    render json: { error: e.message, retry_after: e.retry_after }, status: :too_many_requests
-  rescue StandardError => e
+    render json: {error: e.message, retry_after: e.retry_after}, status: :too_many_requests
+  rescue => e
     Rails.logger.error("[BlazerAI] Generation error: #{e.class}: #{e.message}")
     Rails.logger.error(e.backtrace.first(10).join("\n")) if e.backtrace
-    render json: { error: "An error occurred while generating SQL. Please try again." }, status: :unprocessable_entity
+    render json: {error: "An error occurred while generating SQL. Please try again."}, status: :unprocessable_entity
   end
 
   private
@@ -58,7 +58,7 @@ class Blazer::Ai::QueriesController < Blazer::Ai::ApplicationController
   end
 
   def ensure_ai_enabled
-    render json: { error: "AI features are disabled" }, status: :forbidden unless Blazer::Ai.configuration.enabled?
+    render json: {error: "AI features are disabled"}, status: :forbidden unless Blazer::Ai.configuration.enabled?
   end
 
   def rate_limiter

data/app/overrides/blazer/queries/_form.html.erb

@@ -24,4 +24,4 @@
       <%= link_to "Cancel", queries_path, class: "btn btn-default" %>
     </div>
   </div>
-<% end %>
+<% end %>

data/app/views/blazer/ai/queries/_generate_sql_button.html.erb

@@ -207,4 +207,4 @@
     BlazerAI.init();
   }
 })();
-</script>
+</script>

data/lib/blazer/ai/configuration.rb

@@ -1,11 +1,11 @@
 # Configuration for Blazer AI.
 class Blazer::Ai::Configuration
   attr_accessor :enabled, :default_model, :temperature, :rate_limit_per_minute,
-                :schema_cache_ttl, :max_prompt_length, :max_sql_length
+    :schema_cache_ttl, :max_prompt_length, :max_sql_length
 
   def initialize
     @enabled = true
-    @default_model = "gpt-5.1-codex"
+    @default_model = "gpt-4o-mini"
     @temperature = 0.2
     @rate_limit_per_minute = 20
     @schema_cache_ttl = 12.hours

data/lib/blazer/ai/engine.rb

@@ -1,5 +1,8 @@
 # Rails engine for Blazer AI.
-# Views can be overridden by creating app/views/blazer/ai/queries/_generate_sql_button.html.erb
-class Blazer::Ai::Engine < ::Rails::Engine
-  isolate_namespace Blazer::Ai
+module Blazer
+  module Ai
+    class Engine < ::Rails::Engine
+      isolate_namespace Blazer::Ai
+    end
+  end
 end

data/lib/blazer/ai/middleware.rb

@@ -0,0 +1,219 @@
+# Rack middleware that injects the AI button into Blazer query pages
+# and handles the AI generation API endpoint.
+module Blazer
+  module Ai
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        # Handle AI generation endpoint
+        if ai_generate_request?(env)
+          return handle_ai_generate(env)
+        end
+
+        status, headers, response = @app.call(env)
+
+        # Only inject into HTML responses for Blazer query pages
+        if inject_button?(env, headers)
+          body = extract_body(response)
+          if body.include?("id=\"editor\"") || body.include?("id=\"editor-container\"")
+            body = inject_ai_script(body)
+            headers["Content-Length"] = body.bytesize.to_s
+            response = [body]
+          end
+        end
+
+        [status, headers, response]
+      end
+
+      private
+
+      def ai_generate_request?(env)
+        env["REQUEST_METHOD"] == "POST" &&
+          env["PATH_INFO"].to_s.end_with?("/ai/generate_sql")
+      end
+
+      def handle_ai_generate(env)
+        require "json"
+
+        request = Rack::Request.new(env)
+        params = begin
+          JSON.parse(request.body.read)
+        rescue
+          {}
+        end
+        query_params = params["query"] || {}
+
+        # Basic validation
+        name = query_params["name"].to_s.strip
+        description = query_params["description"].to_s.strip
+
+        if name.empty? && description.empty?
+          return json_response({error: "Name or description required"}, 422)
+        end
+
+        # Check if AI is enabled
+        unless Blazer::Ai.configuration.enabled?
+          return json_response({error: "AI features are disabled"}, 403)
+        end
+
+        # Rate limiting
+        identifier = "ip:#{request.ip}"
+        rate_limiter = RateLimiter.new
+        begin
+          rate_limiter.check_and_track!(identifier: identifier)
+        rescue RateLimiter::RateLimitExceeded => e
+          return json_response({error: e.message, retry_after: e.retry_after}, 429)
+        end
+
+        # Find data source
+        data_source = find_data_source(query_params["data_source"])
+
+        # Generate SQL
+        generator = SqlGenerator.new(
+          params: {name: name, description: description},
+          data_source: data_source
+        )
+
+        begin
+          sql = generator.call
+          json_response({sql: sql}, 200)
+        rescue SqlValidator::ValidationError
+          json_response({error: "Generated SQL failed safety validation"}, 422)
+        rescue SqlGenerator::GenerationError => e
+          json_response({error: e.message}, 422)
+        rescue => e
+          Rails.logger.error("[BlazerAI] Generation error: #{e.class}: #{e.message}") if defined?(Rails.logger)
+          json_response({error: "An error occurred while generating SQL"}, 422)
+        end
+      end
+
+      def find_data_source(data_source_id)
+        return nil if data_source_id.to_s.empty?
+        return nil unless defined?(Blazer) && Blazer.respond_to?(:data_sources)
+        Blazer.data_sources[data_source_id]
+      end
+
+      def json_response(data, status)
+        body = JSON.generate(data)
+        [
+          status,
+          {"Content-Type" => "application/json", "Content-Length" => body.bytesize.to_s},
+          [body]
+        ]
+      end
+
+      def inject_button?(env, headers)
+        return false unless headers["Content-Type"]&.include?("text/html")
+        path = env["PATH_INFO"].to_s
+        path.match?(%r{/queries(/new|/\d+(/edit)?)?$})
+      end
+
+      def extract_body(response)
+        body = +""
+        response.each { |part| body << part }
+        response.close if response.respond_to?(:close)
+        body
+      end
+
+      def inject_ai_script(body)
+        generate_path = Blazer::Ai::UrlHelper.blazer_ai_generate_sql_path
+        script = build_script(generate_path)
+
+        # Find the last </body> tag using rindex to avoid regex issues
+        closing_body_index = body.rindex("</body>")
+        return body unless closing_body_index
+
+        # Insert script before the closing body tag by manual string slicing
+        body[0...closing_body_index] + script + body[closing_body_index..-1]
+      end
+
+      def build_script(generate_path)
+        <<~HTML
+          <style>
+            #blazer-ai-btn { margin-right: 5px; cursor: pointer; }
+            #blazer-ai-btn.loading { opacity: 0.7; }
+            #blazer-ai-btn .spinner { display: none; width: 12px; height: 12px; border: 2px solid transparent; border-top-color: currentColor; border-radius: 50%; animation: bas 0.8s linear infinite; margin-right: 4px; vertical-align: middle; }
+            #blazer-ai-btn.loading .spinner { display: inline-block; }
+            @keyframes bas { to { transform: rotate(360deg); } }
+            #blazer-ai-error { display: none; margin-top: 8px; padding: 8px 12px; background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 4px; color: #721c24; font-size: 13px; }
+            #blazer-ai-error.show { display: block; }
+          </style>
+          <script>
+          (function() {
+            var BA = {
+              loading: false,
+              path: "#{generate_path}",
+              init: function() {
+                var self = this, attempts = 0;
+                var iv = setInterval(function() {
+                  var btn = document.querySelector('input.btn-success[type="submit"][value="Create"], input.btn-success[type="submit"][value="Update"]');
+                  if (btn && !document.getElementById('blazer-ai-btn')) {
+                    clearInterval(iv);
+                    self.inject(btn);
+                  } else if (++attempts > 50) clearInterval(iv);
+                }, 100);
+                document.addEventListener('keydown', function(e) {
+                  if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === 'G') { e.preventDefault(); BA.generate(); }
+                });
+              },
+              inject: function(createBtn) {
+                var btn = document.createElement('a');
+                btn.id = 'blazer-ai-btn';
+                btn.className = 'btn btn-info';
+                btn.innerHTML = '<span class="spinner"></span>AI Generate';
+                btn.onclick = function(e) { e.preventDefault(); BA.generate(); };
+                createBtn.parentNode.insertBefore(btn, createBtn);
+                var err = document.createElement('div');
+                err.id = 'blazer-ai-error';
+                var closeBtn = document.createElement('span');
+                closeBtn.style.cssText = 'float:right;cursor:pointer';
+                closeBtn.textContent = 'x';
+                closeBtn.onclick = function() { err.classList.remove('show'); };
+                var msgSpan = document.createElement('span');
+                msgSpan.className = 'msg';
+                err.appendChild(closeBtn);
+                err.appendChild(msgSpan);
+                createBtn.parentNode.parentNode.appendChild(err);
+              },
+              generate: function() {
+                if (this.loading) return;
+                var name = (document.querySelector('input[name="query[name]"]') || {}).value || '';
+                var desc = (document.querySelector('textarea[name="query[description]"]') || {}).value || '';
+                var ds = (document.querySelector('select[name="query[data_source]"]') || {}).value || '';
+                if (!name.trim() && !desc.trim()) { this.error('Enter a query name or description first.'); return; }
+                this.setLoading(true);
+                this.hideError();
+                fetch(this.path, {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': (document.querySelector('meta[name="csrf-token"]') || {}).content || '' },
+                  body: JSON.stringify({ query: { name: name, description: desc, data_source: ds } })
+                })
+                .then(function(r) { return r.json().then(function(d) { return { status: r.status, data: d }; }); })
+                .then(function(r) {
+                  BA.setLoading(false);
+                  if (r.status === 429) BA.error('Rate limit. Wait ' + (r.data.retry_after || 60) + 's.');
+                  else if (r.status !== 200 || r.data.error) BA.error(r.data.error || 'Generation failed.');
+                  else if (r.data.sql) BA.insertSQL(r.data.sql);
+                })
+                .catch(function() { BA.setLoading(false); BA.error('Network error.'); });
+              },
+              insertSQL: function(sql) {
+                if (typeof editor !== 'undefined') { editor.setValue(sql, 1); editor.focus(); }
+                else { var ta = document.querySelector('textarea[name="query[statement]"]'); if (ta) { ta.value = sql; ta.focus(); } }
+              },
+              setLoading: function(v) { this.loading = v; var b = document.getElementById('blazer-ai-btn'); if (b) b.classList.toggle('loading', v); },
+              error: function(m) { var e = document.getElementById('blazer-ai-error'); if (e) { e.querySelector('.msg').textContent = m; e.classList.add('show'); } },
+              hideError: function() { var e = document.getElementById('blazer-ai-error'); if (e) e.classList.remove('show'); }
+            };
+            if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', function() { BA.init(); });
+            else BA.init();
+          })();
+          </script>
+        HTML
+      end
+    end
+  end
+end

data/lib/blazer/ai/railtie.rb

@@ -1,26 +1,12 @@
 # Integrates Blazer AI into Rails applications.
-# Injects routes into Blazer::Engine and sets up view paths.
 class Blazer::Ai::Railtie < ::Rails::Railtie
-  initializer "blazer_ai.load", before: :load_config_initializers do
+  initializer "blazer_ai.load" do
     require "blazer/ai/engine"
+    require "blazer/ai/middleware"
   end
 
-  initializer "blazer_ai.prepend_view_paths", after: :load_config_initializers do |app|
-    ActiveSupport.on_load(:action_controller) do
-      append_view_path(Blazer::Ai::Engine.root.join("app/views"))
-    end
-  end
-
-  # Inject routes directly into Blazer::Engine to avoid nested engine routing issues
-  initializer "blazer_ai.extend_routes", after: "blazer.routes" do |app|
-    if defined?(Blazer::Engine)
-      Blazer::Engine.routes.prepend do
-        post "/ai/generate_sql" => "ai/queries#create", as: "blazer_ai_generate_sql"
-      end
-
-      ActiveSupport.on_load(:action_controller) do
-        helper Blazer::Ai::UrlHelper
-      end
-    end
+  # Middleware handles both UI injection and API endpoint
+  initializer "blazer_ai.middleware" do |app|
+    app.middleware.use Blazer::Ai::Middleware
   end
 end

data/lib/blazer/ai/schema_cache.rb

@@ -37,7 +37,7 @@ module Blazer::Ai
           columns = connection.columns(table_name).map do |col|
             "#{col.name} (#{col.sql_type})"
           end
-          "#{table_name}: #{columns.join(', ')}"
+          "#{table_name}: #{columns.join(", ")}"
         end.join("\n")
       end
     end

data/lib/blazer/ai/sql_generator.rb

@@ -73,9 +73,9 @@ module Blazer::Ai
       # Timeout to prevent hung requests if LLM provider is slow/unresponsive
       Timeout.timeout(30, GenerationError, "SQL generation timed out. Please try again.") do
         RubyLLM.chat(model: model)
-               .with_temperature(temperature)
-               .ask(prompt)
-               .content
+          .with_temperature(temperature)
+          .ask(prompt)
+          .content
       end
     end
 

data/lib/blazer/ai/url_helper.rb

@@ -8,7 +8,12 @@ module Blazer::Ai::UrlHelper
     path = "/ai/generate_sql"
 
     if defined?(Rails.application)
-      main_route = Rails.application.routes.routes.find { |r| r.name == "blazer" }
+      # Find the route that mounts Blazer::Engine
+      # The route name could be 'blazer', 'admin_blazer', etc.
+      main_route = Rails.application.routes.routes.find do |r|
+        r.app.respond_to?(:app) && r.app.app == Blazer::Engine
+      end
+
       if main_route
         blazer_mount = main_route.path.spec.to_s.gsub("(.:format)", "")
         path = blazer_mount + path

data/lib/blazer/ai/version.rb

@@ -1,5 +1,5 @@
 module Blazer
   module Ai
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/generators/blazer_ai/install_generator.rb

@@ -5,9 +5,26 @@ module BlazerAi
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path("templates", __dir__)
 
-      def copy_initializer
+      def copy_blazer_ai_initializer
         copy_file "blazer_ai.rb", "config/initializers/blazer_ai.rb"
       end
+
+      def copy_ruby_llm_initializer
+        return if ruby_llm_configured?
+
+        copy_file "ruby_llm.rb", "config/initializers/ruby_llm.rb"
+      end
+
+      private
+
+      def ruby_llm_configured?
+        initializers_path = File.join(destination_root, "config/initializers")
+        return false unless File.directory?(initializers_path)
+
+        Dir.glob(File.join(initializers_path, "*.rb")).any? do |file|
+          File.read(file).include?("RubyLLM.configure")
+        end
+      end
     end
   end
 end

data/lib/generators/blazer_ai/templates/blazer_ai.rb

@@ -1,7 +1,3 @@
-RubyLLM.configure do |config|
-  config.openai_api_key = ENV["OPENAI_API_KEY"]
-end
-
 Blazer::Ai.configure do |config|
   config.default_model = "gpt-5.1-codex"
 end

data/lib/generators/blazer_ai/templates/ruby_llm.rb

@@ -0,0 +1,3 @@
+RubyLLM.configure do |config|
+  config.openai_api_key = ENV["OPENAI_API_KEY"]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blazer-ai
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kieran Klaassen
@@ -74,6 +74,7 @@ files:
 - lib/blazer/ai.rb
 - lib/blazer/ai/configuration.rb
 - lib/blazer/ai/engine.rb
+- lib/blazer/ai/middleware.rb
 - lib/blazer/ai/prompt_sanitizer.rb
 - lib/blazer/ai/railtie.rb
 - lib/blazer/ai/rate_limiter.rb
@@ -85,6 +86,7 @@ files:
 - lib/generators/blazer_ai/USAGE
 - lib/generators/blazer_ai/install_generator.rb
 - lib/generators/blazer_ai/templates/blazer_ai.rb
+- lib/generators/blazer_ai/templates/ruby_llm.rb
 homepage: https://github.com/kieranklaassen/blazer-ai
 licenses:
 - MIT