sage-rails 0.0.3

data/config/initializers/ransack.rb

@@ -0,0 +1,152 @@
+require 'ransack'
+
+# Configure Ransack for Blazer models
+Rails.application.config.after_initialize do
+  # Ensure Blazer is loaded first
+  require 'blazer' if defined?(Blazer)
+  
+  # Extend Blazer::Query with Ransack capabilities
+  if defined?(Blazer::Query)
+    # First, ensure Ransack is included in the model
+    unless Blazer::Query.respond_to?(:ransack)
+      Blazer::Query.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+    end
+    
+    Blazer::Query.class_eval do
+      # Define which attributes can be searched
+      def self.ransackable_attributes(auth_object = nil)
+        %w[name description statement creator_id created_at updated_at status]
+      end
+
+      # Define which associations can be searched
+      def self.ransackable_associations(auth_object = nil)
+        associations = %w[checks audits dashboard_queries dashboards]
+        associations << 'creator' if Blazer.user_class
+        associations
+      end
+
+      # Optional: Define custom ransack scopes
+      scope :search_by_keywords, ->(keywords) {
+        sanitized = connection.quote_string(keywords.to_s)
+        where("name ILIKE '%#{sanitized}%' OR description ILIKE '%#{sanitized}%' OR statement ILIKE '%#{sanitized}%'")
+      } if !respond_to?(:search_by_keywords)
+
+      # Make the custom scope available to ransack
+      def self.ransackable_scopes(auth_object = nil)
+        %i[search_by_keywords]
+      end
+    end
+  end
+  
+  # Extend Blazer::Dashboard with Ransack capabilities
+  if defined?(Blazer::Dashboard)
+    # First, ensure Ransack is included in the model
+    unless Blazer::Dashboard.respond_to?(:ransack)
+      Blazer::Dashboard.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+    end
+    
+    Blazer::Dashboard.class_eval do
+      # Define which attributes can be searched
+      def self.ransackable_attributes(auth_object = nil)
+        %w[name creator_id created_at updated_at]
+      end
+
+      # Define which associations can be searched
+      def self.ransackable_associations(auth_object = nil)
+        associations = %w[dashboard_queries queries]
+        associations << 'creator' if Blazer.user_class
+        associations
+      end
+    end
+  end
+end
+
+# Also configure in to_prepare for development reloading
+Rails.application.config.to_prepare do
+  if defined?(Blazer::Query)
+    # Ensure Ransack is included
+    unless Blazer::Query.respond_to?(:ransack)
+      Blazer::Query.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+    end
+    
+    unless Blazer::Query.respond_to?(:ransackable_attributes)
+      Blazer::Query.class_eval do
+        def self.ransackable_attributes(auth_object = nil)
+          %w[name description statement creator_id created_at updated_at status]
+        end
+
+        def self.ransackable_associations(auth_object = nil)
+          %w[creator checks audits dashboard_queries dashboards]
+        end
+
+        def self.ransackable_scopes(auth_object = nil)
+          %i[search_by_keywords]
+        end
+      end
+    end
+  end
+  
+  if defined?(Blazer::Dashboard)
+    # Ensure Ransack is included
+    unless Blazer::Dashboard.respond_to?(:ransack)
+      Blazer::Dashboard.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+    end
+    
+    unless Blazer::Dashboard.respond_to?(:ransackable_attributes)
+      Blazer::Dashboard.class_eval do
+        def self.ransackable_attributes(auth_object = nil)
+          %w[name creator_id created_at updated_at]
+        end
+
+        def self.ransackable_associations(auth_object = nil)
+          associations = %w[dashboard_queries queries]
+          associations << 'creator' if Blazer.user_class
+          associations
+        end
+      end
+    end
+  end
+  
+  if defined?(Blazer::Check)
+    # Ensure Ransack is included
+    unless Blazer::Check.respond_to?(:ransack)
+      Blazer::Check.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+    end
+    
+    unless Blazer::Check.respond_to?(:ransackable_attributes)
+      Blazer::Check.class_eval do
+        def self.ransackable_attributes(auth_object = nil)
+          %w[emails slack_channels check_type schedule state message last_run_at invert creator_id created_at updated_at query_id]
+        end
+
+        def self.ransackable_associations(auth_object = nil)
+          associations = %w[query]
+          associations << 'creator' if Blazer.user_class
+          associations
+        end
+      end
+    end
+  end
+  
+  # Extend Blazer::Check with Ransack capabilities
+  if defined?(Blazer::Check)
+    # First, ensure Ransack is included in the model
+    unless Blazer::Check.respond_to?(:ransack)
+      Blazer::Check.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+    end
+    
+    Blazer::Check.class_eval do
+      # Define which attributes can be searched
+      def self.ransackable_attributes(auth_object = nil)
+        %w[emails slack_channels check_type schedule state message last_run_at invert creator_id created_at updated_at query_id]
+      end
+
+      # Define which associations can be searched
+      def self.ransackable_associations(auth_object = nil)
+        associations = %w[query]
+        associations << 'creator' if Blazer.user_class
+        associations
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,31 @@
+Sage::Engine.routes.draw do
+  get "/close_overlay", to: "actions#close_overlay", as: :close_overlay
+
+  resources :queries, except: [ :index ] do
+    post :refresh, on: :member
+    get :run, on: :member
+
+    resources :messages, only: [:index, :create], controller: 'queries/messages'
+
+    collection do
+      post :run
+      post :cancel
+      get :tables
+      get :schema
+      get :docs
+      get :table_schema
+    end
+  end
+
+  resources :checks, except: [ :show ] do
+    get :run, on: :member
+  end
+
+  resources :dashboards do
+    member do
+      post :refresh
+    end
+  end
+
+  root to: "queries#index"
+end

data/lib/generators/sage/USAGE

@@ -0,0 +1,13 @@
+Description:
+    Installs Sage engine JavaScript files and importmap configuration.
+
+    This generator copies the necessary JavaScript files from the Sage engine
+    to your Rails application and configures importmap-rails to load them.
+
+Example:
+    bin/rails generate sage:install
+
+    This will:
+      1. Copy JavaScript files to app/javascript/sage/
+      2. Add importmap pins to config/importmap.rb
+      3. Display setup instructions

data/lib/generators/sage/install/install_generator.rb

@@ -0,0 +1,128 @@
+require "rails/generators"
+
+module Sage
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Install Sage engine and mount it in your application"
+
+      def install_blazer
+        # Check if Blazer is already installed by looking for migration
+        blazer_installed = Dir.glob("db/migrate/*_install_blazer.rb").any?
+
+        if blazer_installed
+          say "Blazer already installed, skipping...", :yellow
+        else
+          say "Installing Blazer...", :green
+          generate "blazer:install"
+        end
+      end
+
+      def add_routes
+        # Remove existing Blazer route if present
+        routes_file = "config/routes.rb"
+        if File.exist?(routes_file)
+          routes_content = File.read(routes_file)
+
+          # Pattern to match Blazer mount (with various formatting)
+          blazer_route_pattern = /^\s*mount\s+Blazer::Engine\s*,\s*at:\s*['"]blazer['"]\s*$/
+
+          if routes_content.match?(blazer_route_pattern)
+            # Remove the Blazer route
+            gsub_file routes_file, blazer_route_pattern, ""
+            say "Removed existing Blazer route", :yellow
+          end
+        end
+
+        # Mount Sage (which includes Blazer functionality)
+        route 'mount Sage::Engine => "/sage"'
+        say "Mounted Sage at /sage", :green
+      end
+
+      def create_initializer
+        template "sage.rb", "config/initializers/sage.rb"
+      end
+
+      def create_migrations
+        say "Creating Sage database migrations...", :green
+
+        # Generate timestamp for migration
+        timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+
+        # Create the migration file
+        migration_file = "db/migrate/#{timestamp}_create_sage_messages.rb"
+        create_file migration_file do
+          <<~RUBY
+            class CreateSageMessages < ActiveRecord::Migration[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]
+              def change
+                create_table :sage_messages do |t|
+                  t.references :blazer_query
+                  t.references :creator
+                  t.string :body
+                  t.text :statement
+
+                  t.timestamps
+                end
+              end
+            end
+          RUBY
+        end
+
+        say "Created migration for sage_messages table", :green
+      end
+
+      def add_javascript_integration
+        say "Configuring JavaScript integration...", :green
+
+        # Update controllers/index.js to register Sage controllers
+        controllers_index_path = "app/javascript/controllers/index.js"
+        if File.exist?(controllers_index_path)
+          controllers_content = File.read(controllers_index_path)
+          unless controllers_content.include?("sage")
+            append_to_file controllers_index_path do
+              <<~JS
+
+                // Import and register Sage controllers
+                import { registerControllers } from "sage"
+                registerControllers(application)
+              JS
+            end
+            say "Updated controllers/index.js to register Sage controllers", :green
+          else
+            say "Sage controllers already registered in controllers/index.js", :yellow
+          end
+        else
+          say "Could not find app/javascript/controllers/index.js - you'll need to manually import Sage controllers", :yellow
+        end
+      end
+
+      def add_stylesheets
+        # Stylesheets are served directly from the engine via the asset pipeline
+        # No need to copy or require them - they're automatically available
+        say "Sage stylesheets will be served from the engine", :green
+      end
+
+      def display_instructions
+        say "\n" + "="*50, :green
+        say "Sage installation complete!", :green
+        say "="*50, :green
+        say "\nNext steps:"
+        say "1. Run 'bundle install' to install dependencies"
+        say "2. Run 'rails db:migrate' to create Blazer tables"
+        say "3. Configure your AI service in config/initializers/sage.rb"
+        say "4. Visit #{root_url}sage to start using Sage"
+        say "\nFor AI integration, you'll need to:"
+        say "- Set up an Anthropic API key (or OpenAI if preferred)"
+        say "- Add the API key to Rails credentials or .env file"
+        say "- Configure database schema context for better SQL generation"
+      end
+
+      private
+
+      def root_url
+        "http://localhost:3000/"
+      end
+    end
+  end
+end

data/lib/generators/sage/install/templates/sage.rb

@@ -0,0 +1,22 @@
+Sage.configure do |config|
+  # Configure the AI provider (options: :anthropic, :openai)
+  config.provider = :anthropic
+
+  # API Key Configuration
+  # Priority order:
+  # 1. Rails credentials: rails credentials:edit
+  #    anthropic:
+  #      api_key: your_key_here
+  #    openai:
+  #      api_key: your_key_here
+  # 2. .env file: ANTHROPIC_API_KEY=your_key_here or OPENAI_API_KEY=your_key_here
+  # 3. Direct configuration (not recommended for production):
+  # config.anthropic_api_key = "your_key_here"
+  # config.open_ai_key = "your_key_here"
+
+  # Model selection (optional)
+  # For Anthropic (defaults to claude-3-opus-20240229):
+  # config.anthropic_model = "claude-3-sonnet-20240229"
+  # For OpenAI (defaults to gpt-4):
+  # config.open_ai_model = "gpt-3.5-turbo"
+end

data/lib/sage/database_schema_context.rb

@@ -0,0 +1,56 @@
+module Sage
+  class DatabaseSchemaContext
+    def initialize(data_source_name = "main")
+      @data_source_name = data_source_name
+    end
+
+    def self.call(data_source_name = "main")
+      new(data_source_name).build_context
+    end
+
+    def build_context
+      context_parts = []
+      context_parts << "\n\n## DATABASE SCHEMA\n"
+      context_parts << "Available tables and their columns (use these exact names in your queries):\n"
+
+      begin
+        data_source = Blazer.data_sources[@data_source_name]
+        if data_source && data_source.respond_to?(:schema)
+          schema_info = data_source.schema
+
+          # Format the schema array into readable text
+          if schema_info.is_a?(Array)
+            schema_info.each do |table_info|
+              next unless table_info.is_a?(Hash)
+
+              schema_name = table_info[:schema] || "public"
+              table_name = table_info[:table]
+              columns = table_info[:columns] || []
+
+              context_parts << "\n### Table: `#{schema_name}.#{table_name}`"
+              context_parts << "Columns:"
+
+              columns.each do |column|
+                if column.is_a?(Hash)
+                  col_name = column[:name]
+                  data_type = column[:data_type]
+                  context_parts << "  - `#{col_name}` (#{data_type})"
+                end
+              end
+            end
+          else
+            # Fallback to original behavior if schema is not in expected format
+            context_parts << "```"
+            context_parts << schema_info.to_s
+            context_parts << "```"
+          end
+        end
+      rescue => e
+        Rails.logger.warn "Could not load database schema: #{e.message}"
+        return nil
+      end
+
+      context_parts.join("\n")
+    end
+  end
+end

data/lib/sage/engine.rb

@@ -0,0 +1,260 @@
+require "blazer/engine"
+require "importmap-rails"
+require "turbo-rails"
+require "ruby_llm"
+require "ransack"
+
+module Sage
+  class Engine < ::Rails::Engine
+    isolate_namespace Sage
+
+    initializer "sage.importmap", before: "importmap" do |app|
+      if Rails.application.respond_to?(:importmap)
+        # Only add our importmap if it hasn't been added already
+        importmap_path = root.join("config/importmap.rb")
+        unless app.config.importmap.paths.include?(importmap_path)
+          app.config.importmap.paths << importmap_path
+        end
+      end
+    end
+
+    initializer "sage.importmap_helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper Importmap::ImportmapTagsHelper if defined?(Importmap::ImportmapTagsHelper)
+      end
+    end
+
+    initializer "sage.ransack_helpers", after: "ransack" do
+      # Ensure Ransack is fully loaded with its helpers
+      require "ransack" unless defined?(::Ransack)
+
+      # Load Ransack's ActionView extensions which include the helpers
+      if defined?(::Ransack)
+        require "ransack/helpers/form_helper" if !defined?(Ransack::Helpers)
+      end
+
+      ActiveSupport.on_load(:action_controller_base) do
+        if defined?(Ransack::Helpers::FormHelper)
+          helper Ransack::Helpers::FormHelper
+        end
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        if defined?(Ransack::Helpers::FormHelper)
+          include Ransack::Helpers::FormHelper
+        end
+      end
+
+      # Also add to our base controller immediately if it's loaded
+      if defined?(Sage::BaseController) && defined?(Ransack::Helpers::FormHelper)
+        Sage::BaseController.helper Ransack::Helpers::FormHelper
+      end
+    end
+
+    initializer "sage.pagy_helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include Pagy::Frontend if defined?(Pagy::Frontend)
+      end
+    end
+
+    initializer "sage.turbo_helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper Turbo::FramesHelper if defined?(Turbo::FramesHelper)
+        helper Turbo::StreamsHelper if defined?(Turbo::StreamsHelper)
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include Turbo::FramesHelper if defined?(Turbo::FramesHelper)
+        include Turbo::StreamsHelper if defined?(Turbo::StreamsHelper)
+      end
+    end
+
+    initializer "sage.ruby_llm" do
+      RubyLLM.configure do |config|
+        # Determine provider and configure accordingly
+        provider = (Sage.configuration&.provider || :anthropic).to_sym
+
+        case provider
+        when :anthropic
+          config.default_model = Sage.configuration&.anthropic_model || "claude-3-opus-20240229"
+
+          # Determine API key with priority:
+          # 1. Sage configuration (if explicitly set)
+          # 2. Rails credentials
+          # 3. Local .env file
+          api_key = nil
+
+          # Check if explicitly configured in Sage
+          if Sage.configuration && Sage.configuration.anthropic_api_key
+            api_key = Sage.configuration.anthropic_api_key
+          end
+
+          # Try Rails credentials
+          if api_key.nil? && defined?(Rails.application.credentials)
+            api_key = Rails.application.credentials.dig(:anthropic, :api_key)
+          end
+
+          # Try .env file
+          if api_key.nil? && defined?(Rails.root)
+            env_path = Rails.root.join(".env")
+            if File.exist?(env_path)
+              require "dotenv"
+              env_vars = Dotenv.parse(env_path)
+              api_key = env_vars["ANTHROPIC_API_KEY"]
+            end
+          end
+
+          config.anthropic_api_key = api_key
+
+        when :openai
+          config.default_model = Sage.configuration&.open_ai_model || "gpt-4"
+
+          # Determine API key with priority:
+          # 1. Sage configuration (if explicitly set)
+          # 2. Rails credentials
+          # 3. Local .env file
+          api_key = nil
+
+          # Check if explicitly configured in Sage
+          if Sage.configuration && Sage.configuration.open_ai_key
+            api_key = Sage.configuration.open_ai_key
+          end
+
+          # Try Rails credentials
+          if api_key.nil? && defined?(Rails.application.credentials)
+            api_key = Rails.application.credentials.dig(:openai, :api_key)
+          end
+
+          # Try .env file
+          if api_key.nil? && defined?(Rails.root)
+            env_path = Rails.root.join(".env")
+            if File.exist?(env_path)
+              require "dotenv"
+              env_vars = Dotenv.parse(env_path)
+              api_key = env_vars["OPENAI_API_KEY"]
+            end
+          end
+
+          config.openai_api_key = api_key
+        end
+      end
+    end
+
+    initializer "sage.assets" do |app|
+      # Add JavaScript path for Propshaft
+      if defined?(Propshaft::Railtie)
+        app.config.assets.paths << Engine.root.join("app/javascript")
+        app.config.assets.paths << Engine.root.join("app/javascript/sage")
+      end
+
+      if app.config.respond_to?(:assets)
+        # Blazer assets
+        blazer_css_assets = [
+          "blazer/selectize.css",
+          "blazer/daterangepicker.css"
+        ]
+
+        blazer_js_assets = [
+          "blazer/jquery.js",
+          "blazer/rails-ujs.js",
+          "blazer/stupidtable.js",
+          "blazer/stupidtable-custom-settings.js",
+          "blazer/jquery.stickytableheaders.js",
+          "blazer/selectize.js",
+          "blazer/highlight.min.js",
+          "blazer/moment.js",
+          "blazer/moment-timezone-with-data.js",
+          "blazer/daterangepicker.js",
+          "blazer/chart.umd.js",
+          "blazer/chartjs-adapter-date-fns.bundle.js",
+          "blazer/chartkick.js",
+          "blazer/mapkick.bundle.js",
+          "blazer/ace/ace.js",
+          "blazer/ace/ext-language_tools.js",
+          "blazer/ace/theme-twilight.js",
+          "blazer/ace/mode-sql.js",
+          "blazer/ace/snippets/text.js",
+          "blazer/ace/snippets/sql.js",
+          "blazer/Sortable.js",
+          "blazer/bootstrap.js",
+          "blazer/vue.global.prod.js",
+          "blazer/routes.js",
+          "blazer/queries.js",
+          "blazer/fuzzysearch.js",
+          "blazer/application.js"
+        ]
+
+        sage_assets = [
+          "sage.js",
+          "sage/application.js",
+          "sage/application.css",
+          "sage/controllers/search_controller.js",
+          "sage/controllers/clipboard_controller.js",
+          "sage/controllers/select_controller.js",
+          "sage/controllers/dashboard_controller.js",
+          "sage/controllers/reverse_infinite_scroll_controller.js"
+        ]
+
+        if defined?(Sprockets)
+          if Sprockets::VERSION.to_i >= 4
+            app.config.assets.precompile += blazer_css_assets + blazer_js_assets + sage_assets
+          else
+            # use a proc instead of a string
+            app.config.assets.precompile << proc { |path| path =~ /\Asage\/.+\.css\z/ }
+            app.config.assets.precompile << proc { |path| path =~ /\Asage\/.+\.js\z/ }
+            app.config.assets.precompile << proc { |path| path =~ /\Asage\/controllers\/.+\.js\z/ }
+            app.config.assets.precompile << proc { |path| path =~ /\Ablazer\/.+\.css\z/ }
+            app.config.assets.precompile << proc { |path| path =~ /\Ablazer\/.+\.js\z/ }
+          end
+        else
+          # For Propshaft
+          app.config.assets.precompile += blazer_css_assets + blazer_js_assets + sage_assets
+        end
+      end
+    end
+
+
+    config.to_prepare do
+      # Ensure Ransack is loaded
+      require "ransack" if defined?(::Ransack).nil?
+
+      # Ensure we can access Blazer's models and controllers
+      Dir.glob(Rails.root.join("app/models/blazer/*.rb")).each { |file| require_dependency file }
+
+      # Load ransack configuration for Blazer::Query
+      initializer_path = Engine.root.join("config/initializers/ransack.rb")
+      load initializer_path if File.exist?(initializer_path)
+
+      # Extend Blazer::Query with associations
+      if defined?(Blazer::Query)
+        # Ensure Ransack is available for Blazer::Query
+        unless Blazer::Query.respond_to?(:ransack)
+          Blazer::Query.send(:extend, Ransack::Adapters::ActiveRecord::Base)
+        end
+
+        Blazer::Query.class_eval do
+          has_many :messages, class_name: "Sage::Message", foreign_key: :blazer_query_id, dependent: :destroy
+
+          # Define ransackable attributes if not already defined
+          unless respond_to?(:ransackable_attributes)
+            def self.ransackable_attributes(auth_object = nil)
+              %w[name description statement creator_id created_at updated_at status]
+            end
+
+            def self.ransackable_associations(auth_object = nil)
+              %w[creator checks audits dashboard_queries dashboards messages]
+            end
+          end
+        end
+      end
+    end
+
+    # Autoload schemas
+    config.autoload_paths += %W[#{root}/app/schemas]
+
+    # Make Blazer available at the top level
+    config.before_initialize do
+      require "blazer"
+    end
+  end
+end