mysql_genius 0.3.1 → 0.4.0

data/app/controllers/concerns/mysql_genius/query_execution.rb

@@ -12,103 +12,61 @@ module MysqlGenius
         mysql_genius_config.default_row_limit
       end
 
-      error = validate_sql(sql)
-      if error
-        audit(:rejection, sql: sql, reason: error)
-        return render(json: { error: error }, status: :unprocessable_entity)
-      end
-
-      limited_sql = apply_row_limit(sql, row_limit)
-      timed_sql = apply_timeout_hint(limited_sql)
+      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
+      runner_config = MysqlGenius::Core::QueryRunner::Config.new(
+        blocked_tables: mysql_genius_config.blocked_tables,
+        masked_column_patterns: mysql_genius_config.masked_column_patterns,
+        query_timeout_ms: mysql_genius_config.query_timeout_ms,
+      )
+      runner = MysqlGenius::Core::QueryRunner.new(connection, runner_config)
 
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       begin
-        results = ActiveRecord::Base.connection.exec_query(timed_sql)
-        execution_time_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(1)
-
-        columns = results.columns
-        rows = results.rows.map do |row|
-          row.each_with_index.map do |value, i|
-            masked_column?(columns[i]) ? "[REDACTED]" : value
-          end
-        end
-
-        truncated = rows.length >= row_limit
-
-        audit(:query, sql: sql, execution_time_ms: execution_time_ms, row_count: rows.length)
-
-        render(json: {
-          columns: columns,
-          rows: rows,
-          row_count: rows.length,
-          execution_time_ms: execution_time_ms,
-          truncated: truncated,
-        })
+        result = runner.run(sql, row_limit: row_limit)
+      rescue MysqlGenius::Core::QueryRunner::Rejected => e
+        audit(:rejection, sql: sql, reason: e.message)
+        return render(json: { error: e.message }, status: :unprocessable_entity)
+      rescue MysqlGenius::Core::QueryRunner::Timeout
+        audit(:error, sql: sql, error: "Query timeout")
+        return render(json: { error: "Query exceeded the #{mysql_genius_config.query_timeout_ms / 1000} second timeout limit.", timeout: true }, status: :unprocessable_entity)
       rescue ActiveRecord::StatementInvalid => e
-        if timeout_error?(e)
-          audit(:error, sql: sql, error: "Query timeout")
-          render(json: { error: "Query exceeded the #{mysql_genius_config.query_timeout_ms / 1000} second timeout limit.", timeout: true }, status: :unprocessable_entity)
-        else
-          audit(:error, sql: sql, error: e.message)
-          render(json: { error: "Query error: #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
-        end
+        audit(:error, sql: sql, error: e.message)
+        return render(json: { error: "Query error: #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
       end
+
+      audit(:query, sql: sql, execution_time_ms: result.execution_time_ms, row_count: result.row_count)
+
+      render(json: {
+        columns: result.columns,
+        rows: result.rows,
+        row_count: result.row_count,
+        execution_time_ms: result.execution_time_ms,
+        truncated: result.truncated,
+      })
     end
 
     def explain
       sql = params[:sql].to_s.strip
       skip_validation = params[:from_slow_query] == "true"
 
-      unless skip_validation
-        error = validate_sql(sql)
-        return render(json: { error: error }, status: :unprocessable_entity) if error
-      end
-
-      # Reject truncated SQL (captured slow queries are capped at 2000 chars)
-      unless sql.match?(/\)\s*$/) || sql.match?(/\w\s*$/) || sql.match?(/['"`]\s*$/) || sql.match?(/\d\s*$/)
-        return render(json: { error: "This query appears to be truncated and cannot be explained." }, status: :unprocessable_entity)
-      end
-
-      explain_sql = "EXPLAIN #{sql.gsub(/;\s*\z/, "")}"
-      results = ActiveRecord::Base.connection.exec_query(explain_sql)
-
-      render(json: { columns: results.columns, rows: results.rows })
+      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
+      runner_config = MysqlGenius::Core::QueryRunner::Config.new(
+        blocked_tables: mysql_genius_config.blocked_tables,
+        masked_column_patterns: mysql_genius_config.masked_column_patterns,
+        query_timeout_ms: mysql_genius_config.query_timeout_ms,
+      )
+      explainer = MysqlGenius::Core::QueryExplainer.new(connection, runner_config)
+
+      result = explainer.explain(sql, skip_validation: skip_validation)
+      render(json: { columns: result.columns, rows: result.rows })
+    rescue MysqlGenius::Core::QueryRunner::Rejected,
+           MysqlGenius::Core::QueryExplainer::Truncated => e
+      render(json: { error: e.message }, status: :unprocessable_entity)
     rescue ActiveRecord::StatementInvalid => e
       render(json: { error: "Explain error: #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
     end
 
     private
 
-    def validate_sql(sql)
-      SqlValidator.validate(sql, blocked_tables: mysql_genius_config.blocked_tables, connection: ActiveRecord::Base.connection)
-    end
-
-    def apply_timeout_hint(sql)
-      if mariadb?
-        timeout_seconds = mysql_genius_config.query_timeout_ms / 1000
-        "SET STATEMENT max_statement_time=#{timeout_seconds} FOR #{sql}"
-      else
-        sql.sub(/\bSELECT\b/i, "SELECT /*+ MAX_EXECUTION_TIME(#{mysql_genius_config.query_timeout_ms}) */")
-      end
-    end
-
-    def mariadb?
-      @mariadb ||= ActiveRecord::Base.connection.select_value("SELECT VERSION()").to_s.include?("MariaDB")
-    end
-
-    def apply_row_limit(sql, limit)
-      SqlValidator.apply_row_limit(sql, limit)
-    end
-
-    def timeout_error?(exception)
-      msg = exception.message
-      msg.include?("max_statement_time") || msg.include?("max_execution_time") || msg.include?("Query execution was interrupted")
-    end
-
-    def masked_column?(column_name)
-      SqlValidator.masked_column?(column_name, mysql_genius_config.masked_column_patterns)
-    end
-
     def sanitize_ai_sql(sql)
       sql.gsub(/```(?:sql)?\s*/i, "").gsub("```", "").strip
     end

data/app/views/mysql_genius/queries/_tab_query_stats.html.erb

@@ -2,16 +2,6 @@
 <div class="mg-tab-content" id="tab-qstats">
   <div class="mg-row" style="justify-content:space-between;align-items:center;margin-bottom:12px;">
     <div class="mg-text-muted">Top queries from <code>performance_schema.events_statements_summary_by_digest</code>. <span id="qstats-count" class="mg-badge mg-badge-secondary"></span></div>
-    <!--div>
-      <label style="display:inline;font-size:12px;margin-right:4px;">Sort by:</label>
-      <select id="qstats-sort" style="width:auto;display:inline-block;padding:3px 6px;font-size:12px;">
-        <option value="total_time">Total Time</option>
-        <option value="avg_time">Avg Time</option>
-        <option value="calls">Calls</option>
-        <option value="rows_examined">Rows Examined</option>
-      </select>
-      <button id="qstats-refresh" class="mg-btn mg-btn-outline-secondary mg-btn-sm" style="margin-left:4px;">&#8635; Refresh</button>
-    </div-->
   </div>
   <div id="qstats-loading" class="mg-text-center mg-hidden"><span class="mg-spinner"></span> Loading...</div>
   <div id="qstats-error" class="mg-hidden"></div>

data/app/views/mysql_genius/queries/index.html.erb

@@ -1037,8 +1037,7 @@
     hide(el('qstats-empty')); hide(el('qstats-table-wrapper')); hide(el('qstats-error'));
     el('qstats-tbody').innerHTML = '';
 
-    var sort = el('qstats-sort').value;
-    ajaxGet(ROUTES.query_stats, { sort: sort }, function(data) {
+    ajaxGet(ROUTES.query_stats, { sort: 'total_time' }, function(data) {
       hide(el('qstats-loading'));
       if (data.error) {
         el('qstats-error').innerHTML = '<div class="mg-alert mg-alert-warning">' + escHtml(data.error) + '</div>';
@@ -1074,9 +1073,6 @@
     return ms.toFixed(1) + ' ms';
   }
 
-  el('qstats-refresh').addEventListener('click', loadQueryStats);
-  el('qstats-sort').addEventListener('change', loadQueryStats);
-
   // --- Unused Indexes ---
 
   function loadUnusedIndexes() {

data/lib/mysql_genius/core/connection/active_record_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "mysql_genius/core"
+
+module MysqlGenius
+  module Core
+    module Connection
+      # Wraps an ActiveRecord::Base.connection and implements the
+      # Core::Connection contract. Lives in the mysql_genius (Rails
+      # adapter) gem because it depends on ActiveRecord; the contract
+      # itself lives in mysql_genius-core.
+      class ActiveRecordAdapter
+        def initialize(ar_connection)
+          @ar = ar_connection
+        end
+
+        def exec_query(sql, binds: [])
+          _ = binds
+          ar_result = @ar.exec_query(sql)
+          Core::Result.new(columns: ar_result.columns, rows: ar_result.rows)
+        end
+
+        def select_value(sql)
+          @ar.select_value(sql)
+        end
+
+        def server_version
+          Core::ServerInfo.parse(@ar.select_value("SELECT VERSION()").to_s)
+        end
+
+        def current_database
+          @ar.current_database
+        end
+
+        def quote(value)
+          @ar.quote(value)
+        end
+
+        def quote_table_name(name)
+          @ar.quote_table_name(name)
+        end
+
+        def tables
+          @ar.tables
+        end
+
+        def columns_for(table)
+          pk = @ar.primary_key(table)
+          @ar.columns(table).map do |c|
+            Core::ColumnDefinition.new(
+              name: c.name,
+              type: c.type,
+              sql_type: c.sql_type,
+              null: c.null,
+              default: c.default,
+              primary_key: c.name == pk,
+            )
+          end
+        end
+
+        def indexes_for(table)
+          @ar.indexes(table).map do |idx|
+            Core::IndexDefinition.new(name: idx.name, columns: idx.columns, unique: idx.unique)
+          end
+        end
+
+        def primary_key(table)
+          @ar.primary_key(table)
+        end
+
+        def close
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/mysql_genius/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MysqlGenius
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/mysql_genius.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require "mysql_genius/version"
+require "mysql_genius/core"
+require "mysql_genius/core/connection/active_record_adapter"
 require "mysql_genius/configuration"
-require "mysql_genius/sql_validator"
 
 module MysqlGenius
   class Error < StandardError; end

data/mysql_genius.gemspec

@@ -24,12 +24,13 @@ Gem::Specification.new do |spec|
   spec.metadata["changelog_uri"]   = "#{spec.homepage}/blob/main/CHANGELOG.md"
 
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
-    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    %x(git ls-files -z).split("\x0").reject { |f| f.match(%r{^(test|spec|features|gems)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency("activerecord", ">= 5.2", "< 9")
+  spec.add_dependency("mysql_genius-core", "~> 0.4.0")
   spec.add_dependency("railties", ">= 5.2", "< 9")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mysql_genius
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Antarr Byrd
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-10 00:00:00.000000000 Z
+date: 2026-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -30,6 +30,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
+- !ruby/object:Gem::Dependency
+  name: mysql_genius-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -76,9 +90,6 @@ files:
 - app/controllers/concerns/mysql_genius/query_execution.rb
 - app/controllers/mysql_genius/base_controller.rb
 - app/controllers/mysql_genius/queries_controller.rb
-- app/services/mysql_genius/ai_client.rb
-- app/services/mysql_genius/ai_optimization_service.rb
-- app/services/mysql_genius/ai_suggestion_service.rb
 - app/views/layouts/mysql_genius/application.html.erb
 - app/views/mysql_genius/queries/_shared_results.html.erb
 - app/views/mysql_genius/queries/_tab_ai_tools.html.erb
@@ -101,15 +112,13 @@ files:
 - docs/screenshots/query_stats.png
 - docs/screenshots/server.png
 - docs/screenshots/table_sizes.png
-- docs/superpowers/plans/2026-04-08-dashboard-first-redesign.md
-- docs/superpowers/specs/2026-04-08-dashboard-first-redesign.md
 - lib/generators/mysql_genius/install/install_generator.rb
 - lib/generators/mysql_genius/install/templates/initializer.rb
 - lib/mysql_genius.rb
 - lib/mysql_genius/configuration.rb
+- lib/mysql_genius/core/connection/active_record_adapter.rb
 - lib/mysql_genius/engine.rb
 - lib/mysql_genius/slow_query_monitor.rb
-- lib/mysql_genius/sql_validator.rb
 - lib/mysql_genius/version.rb
 - mysql_genius.gemspec
 homepage: https://github.com/antarr/mysql_genius

data/app/services/mysql_genius/ai_client.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json"
-require "uri"
-
-module MysqlGenius
-  class AiClient
-    MAX_REDIRECTS = 3
-
-    def initialize
-      @config = MysqlGenius.configuration
-    end
-
-    def chat(messages:, temperature: 0)
-      if @config.ai_client
-        return @config.ai_client.call(messages: messages, temperature: temperature)
-      end
-
-      raise Error, "AI is not configured" unless @config.ai_endpoint && @config.ai_api_key
-
-      body = {
-        messages: messages,
-        response_format: { type: "json_object" },
-        temperature: temperature,
-      }
-      body[:model] = @config.ai_model if @config.ai_model && !@config.ai_model.empty?
-
-      response = post_with_redirects(URI(@config.ai_endpoint), body.to_json)
-      parsed = JSON.parse(response.body)
-
-      if parsed["error"]
-        raise Error, "AI API error: #{parsed["error"]["message"] || parsed["error"]}"
-      end
-
-      content = parsed.dig("choices", 0, "message", "content")
-      raise Error, "No content in AI response" if content.nil?
-
-      parse_json_content(content)
-    end
-
-    private
-
-    def parse_json_content(content)
-      # Try direct parse first
-      JSON.parse(content)
-    rescue JSON::ParserError
-      # Strip markdown code fences that some models wrap around JSON
-      stripped = content.to_s
-        .gsub(/\A\s*```(?:json)?\s*/i, "")
-        .gsub(/\s*```\s*\z/, "")
-        .strip
-      begin
-        JSON.parse(stripped)
-      rescue JSON::ParserError
-        { "raw" => content.to_s }
-      end
-    end
-
-    def post_with_redirects(uri, body, redirects = 0)
-      raise Error, "Too many redirects" if redirects > MAX_REDIRECTS
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == "https"
-      if http.use_ssl?
-        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        cert_file = ENV["SSL_CERT_FILE"] || OpenSSL::X509::DEFAULT_CERT_FILE
-        http.ca_file = cert_file if File.exist?(cert_file)
-      end
-      http.open_timeout = 10
-      http.read_timeout = 60
-
-      request = Net::HTTP::Post.new(uri)
-      request["Content-Type"] = "application/json"
-      if @config.ai_auth_style == :bearer
-        request["Authorization"] = "Bearer #{@config.ai_api_key}"
-      else
-        request["api-key"] = @config.ai_api_key
-      end
-      request.body = body
-
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPRedirection)
-        post_with_redirects(URI(response["location"]), body, redirects + 1)
-      else
-        response
-      end
-    end
-  end
-end

data/app/services/mysql_genius/ai_optimization_service.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module MysqlGenius
-  class AiOptimizationService
-    def call(sql, explain_rows, allowed_tables)
-      schema = build_schema_description(allowed_tables)
-      messages = [
-        { role: "system", content: system_prompt(schema) },
-        { role: "user", content: user_prompt(sql, explain_rows) },
-      ]
-
-      AiClient.new.chat(messages: messages)
-    end
-
-    private
-
-    def system_prompt(schema_description)
-      <<~PROMPT
-        You are a MySQL query optimization expert. Given a SQL query and its EXPLAIN output, analyze the query execution plan and provide actionable optimization suggestions.
-
-        Available schema:
-        #{schema_description}
-
-        Respond with JSON:
-        {
-          "suggestions": "Markdown-formatted analysis and suggestions. Include: 1) Summary of current execution plan (scan types, rows examined). 2) Specific recommendations such as indexes to add (provide exact CREATE INDEX statements), query rewrites, or structural changes. 3) Expected impact of each suggestion."
-        }
-      PROMPT
-    end
-
-    def user_prompt(sql, explain_rows)
-      <<~PROMPT
-        SQL Query:
-        #{sql}
-
-        EXPLAIN Output:
-        #{format_explain(explain_rows)}
-      PROMPT
-    end
-
-    def format_explain(explain_rows)
-      return explain_rows if explain_rows.is_a?(String)
-
-      explain_rows.map { |row| row.join(" | ") }.join("\n")
-    end
-
-    def build_schema_description(allowed_tables)
-      connection = ActiveRecord::Base.connection
-      allowed_tables.map do |table|
-        next unless connection.tables.include?(table)
-
-        columns = connection.columns(table).map { |c| "#{c.name} (#{c.type})" }
-        indexes = connection.indexes(table).map { |idx| "#{idx.name}: [#{idx.columns.join(", ")}]#{" UNIQUE" if idx.unique}" }
-        desc = "#{table}: #{columns.join(", ")}"
-        desc += "\n  Indexes: #{indexes.join("; ")}" if indexes.any?
-        desc
-      end.compact.join("\n")
-    end
-  end
-end

data/app/services/mysql_genius/ai_suggestion_service.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module MysqlGenius
-  class AiSuggestionService
-    def call(user_prompt, allowed_tables)
-      schema = build_schema_description(allowed_tables)
-      messages = [
-        { role: "system", content: system_prompt(schema) },
-        { role: "user", content: user_prompt },
-      ]
-
-      AiClient.new.chat(messages: messages)
-    end
-
-    private
-
-    def system_prompt(schema_description)
-      custom_context = MysqlGenius.configuration.ai_system_context
-
-      prompt = <<~PROMPT
-        You are a SQL query assistant for a MySQL database.
-      PROMPT
-
-      if custom_context && !custom_context.empty?
-        prompt += <<~PROMPT
-
-          Domain context:
-          #{custom_context}
-        PROMPT
-      end
-
-      prompt += <<~PROMPT
-
-        Rules:
-        - Only generate SELECT statements. Never generate INSERT, UPDATE, DELETE, or any other mutation.
-        - Only reference the tables and columns listed in the schema below. Do not guess or invent column names.
-        - Use backticks for table and column names.
-        - Include a LIMIT 100 unless the user specifies otherwise.
-
-        Available schema:
-        #{schema_description}
-
-        Respond with JSON: {"sql": "the SQL query", "explanation": "brief explanation of what the query does"}
-      PROMPT
-
-      prompt
-    end
-
-    def build_schema_description(allowed_tables)
-      connection = ActiveRecord::Base.connection
-      allowed_tables.map do |table|
-        next unless connection.tables.include?(table)
-
-        columns = connection.columns(table).map { |c| "#{c.name} (#{c.type})" }
-        "#{table}: #{columns.join(", ")}"
-      end.compact.join("\n")
-    end
-  end
-end