mysql_genius 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7858ff8adbac9ab758eee1f82b0302f67cc09357ad087f3a3102a6646307f9d
-  data.tar.gz: 72053d61ff33d5fbf986a7a60445e36ae821ec9c2368ef4c9a0e4768636cb6ec
+  metadata.gz: a35fb751622eaa5cd7bc6fad555020fb5dbf2a9a2f50d50d27ee9b3da6440818
+  data.tar.gz: 1423b66748df1f05b0a9e9ff3868d35905953218443823e9cf2b0a554e88c4db
 SHA512:
-  metadata.gz: 8dd7d033566d1ba8112253768dd491a5083f2daf57f2eb96231f668f229bac16572d97735d86a873efe6d9b44b7fdc649a31647ba10470c877a5c353dd0ebf53
-  data.tar.gz: b25231d00d367295acc3c84e612bd4345fc3a954a48aa7b93a17c8fec50bb5804936e9605b1663971566542626c93f65fc49522900e36f667ff6d6073143d11c
+  metadata.gz: 8fbd465309eb1068b2c78cc47e56e93ac98badd97f8df834a306cbda5c114f903f410c5a7e927c6e9079556d2a240e44521290a28b959e9af91805f13b1fe22d
+  data.tar.gz: 2f3fe565bd970da7f1a1ac0f331bc435a59cc5508b1094fdc91003ef01f5fd3fb7782618cc7d55e24e5aec243f597895b5d4bd1238e90b150d5d92ba2cf611ef

data/.github/workflows/ci.yml

@@ -14,17 +14,8 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ["2.7", "3.0", "3.1", "3.2", "3.3", "3.4"]
-        rails: ["5.2", "6.0", "6.1", "7.0", "7.1", "7.2", "8.0", "8.1"]
+        rails: ["6.0", "6.1", "7.0", "7.1", "7.2", "8.0", "8.1"]
         exclude:
-          # Rails 5.2 doesn't support Ruby 3.1+
-          - ruby: "3.1"
-            rails: "5.2"
-          - ruby: "3.2"
-            rails: "5.2"
-          - ruby: "3.3"
-            rails: "5.2"
-          - ruby: "3.4"
-            rails: "5.2"
           # Rails 6.0 doesn't support Ruby 3.2+
           - ruby: "3.2"
             rails: "6.0"
@@ -61,7 +52,7 @@ jobs:
       RAILS_VERSION: ${{ matrix.rails }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Set up Ruby ${{ matrix.ruby }}
         uses: ruby/setup-ruby@v1

data/.github/workflows/publish.yml

@@ -9,7 +9,7 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 3.3
@@ -25,7 +25,7 @@ jobs:
     needs: test
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 3.3

data/.rubocop.yml

@@ -17,6 +17,9 @@ RSpec/MessageSpies:
 RSpec/VerifiedDoubles:
   Enabled: false
 
+RSpec/VerifiedDoubleReference:
+  Enabled: false
+
 RSpec/ExampleLength:
   Max: 25
 

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## 0.6.0
+
+### Changed
+- **Dropped Rails 5.2 support.** The gemspec floor is now Rails 6.0 (`activerecord`/`railties` constraint is `">= 6.0", "< 9"`). Rails 5.2 has been end-of-life since June 2022 and its incompatibilities with modern Rack (`ActionDispatch::Static#initialize` arity mismatch, `MiddlewareStack#operations` removal) started surfacing as CI failures once Phase 2a's integration specs booted Rails in test. Pin `mysql_genius 0.5.0` (`gem "mysql_genius", "~> 0.5.0"`) if you can't upgrade Rails yet.
+- `mysql_genius` now declares runtime dependency on `mysql_genius-core ~> 0.6.0` (was `~> 0.5.0`).
+
+### Fixed
+- **CI matrix: Ruby 3.x + Rails 5.2/6.0/6.1 compatibility.** `spec/rails_helper.rb` and `spec/dummy/config/application.rb` now explicitly `require "logger"` before loading Rails. Works around a `Logger::Severity` reference inside `ActiveSupport::LoggerThreadSafeLevel` that fails on Ruby 3.x + older Rails because Logger is no longer autoloaded in modern Ruby. Only affects the test suite; no runtime impact on host apps.
+
+### Internal
+- **`rails_connection` consolidated into `BaseController`.** Nine inline `MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)` call sites in the three controller concerns, plus two separate private helper definitions in `QueriesController` and `AiFeatures`, collapse to one private method on `BaseController`. Shared across all concerns via Ruby's standard method lookup.
+- **`ai_domain_context` helper inlined and deleted.** Its two remaining callers (`anomaly_detection` and `root_cause`) now compute a local `domain_ctx` string before building their message array.
+- **`fake_result(columns:, rows:, to_a:)` test helper extracted** into `spec/support/fake_connection.rb` alongside `fake_column`. Four duplicated `instance_double("ActiveRecord::Result", columns:, rows:, to_a:)` call sites in request specs refactored.
+- **`Core::Analysis::Columns` spec** covers the `default: false` branch (6th column outside `default_columns`).
+- **`actions/checkout@v4` bumped to `@v5`** in both `.github/workflows/ci.yml` and `.github/workflows/publish.yml`. Prepares for GitHub's June 2026 Node 20 deprecation.
+- **Gemspec `source_code_uri` duplicate dropped** from both gemspecs (was equal to `homepage_uri` and triggered a RubyGems build warning on every release).
+
+### Documentation
+- README Compatibility table no longer lists Rails 5.2. The note explaining the drop and pinning instructions stays in place.
+
+## 0.5.0
+
+### Changed
+- **ERB templates moved into `mysql_genius-core`.** All 11 view files (`dashboard.html.erb` and 10 partials) have been extracted from `app/views/mysql_genius/queries/` into `gems/mysql_genius-core/lib/mysql_genius/core/views/mysql_genius/queries/`. The index template is renamed to `dashboard.html.erb`. The engine registers `MysqlGenius::Core.views_path` before `:add_view_paths` so Rails finds templates in both view roots. Non-Rails adapters (Phase 2b `mysql_genius-desktop` sidecar) can register this same path with their own view loader and implement `path_for`/`render_partial` to reuse the templates.
+- **`QueriesController#index`** now sets `@framework_version_major` and `@framework_version_minor` instance variables (replacing direct `Rails::VERSION` references in the template) and explicitly renders `"mysql_genius/queries/dashboard"`.
+- **`SharedViewHelpers`** — new concern providing `path_for(name)` and `render_partial(name)` as the 2-method contract the shared templates depend on. `render_partial` delegates to `view_context.render(partial: "mysql_genius/queries/#{name}")`.
+- Extracted 5 AI prompt builders from the `AiFeatures` concern into `MysqlGenius::Core::Ai::{DescribeQuery, SchemaReview, RewriteQuery, IndexAdvisor, MigrationRisk}` plus a shared `Core::Ai::SchemaContextBuilder` helper. `anomaly_detection` and `root_cause` remain in the Rails concern because they depend on the Redis-backed `SlowQueryMonitor`.
+- Extracted `QueriesController#columns` logic into `MysqlGenius::Core::Analysis::Columns` with a tagged-result struct. Retires the `masked_column?` helper added in the 0.4.1 hotfix.
+- `MysqlGenius::Core::Ai::Config` gains a `domain_context:` field. The Rails adapter defaults it to a Rails-specific string; `mysql_genius-desktop` will default to empty.
+- `mysql_genius` now declares runtime dependency on `mysql_genius-core ~> 0.5.0` (was `~> 0.4.0`).
+
+### Added
+- Integration test suite at `spec/dummy/` + `spec/rails_helper.rb` + `spec/requests/`. Boots a minimal Rails engine dummy app and dispatches real HTTP requests against the mounted engine via `Rack::Test`. Dedicated regression specs at `spec/regressions/` pin the two Phase 1b latent bugs (`Core::Connection::ActiveRecordAdapter` boot-order and `QueriesController#masked_column?` helper deletion) so they can never silently return.
+- `CLAUDE.md` updated: the "no Rails boot in tests" rule is relaxed to a two-tier model (unit specs stub AR, integration specs boot Rails via `spec/dummy/`).
+
+### Internal
+- `MysqlGenius::Core.views_path` — new public module method returning the absolute path to the shared ERB template directory.
+
 ## 0.4.1
 
 ### Fixed

data/Gemfile

@@ -16,6 +16,8 @@ end
 group :development, :test do
   gem "rake"
   gem "rspec", "~> 3.0"
+  gem "rspec-rails"
+  gem "rack-test"
   gem "rubocop"
   gem "rubocop-shopify"
   gem "rubocop-rspec"

data/README.md

@@ -134,7 +134,6 @@ This helps if the problem is a stale trust store, but does **not** help if the u
 
 | Rails | Ruby |
 |-------|------|
-| 5.2   | 2.7, 3.0 |
 | 6.0   | 2.7, 3.0, 3.1 |
 | 6.1   | 2.7, 3.0, 3.1, 3.2, 3.3 |
 | 7.0   | 2.7, 3.0, 3.1, 3.2, 3.3 |
@@ -143,6 +142,8 @@ This helps if the problem is a stale trust store, but does **not** help if the u
 | 8.0   | 3.2, 3.3, 3.4 |
 | 8.1   | 3.2, 3.3, 3.4 |
 
+> **Rails 5.2:** dropped in `mysql_genius 0.6.0`. `mysql_genius 0.5.0` is the last version to support Rails 5.2 — pin it (`gem "mysql_genius", "~> 0.5.0"`) if you can't upgrade Rails yet. Rails 5.2 has been end-of-life since June 2022, and its incompatibilities with modern Rack (`ActionDispatch::Static#initialize` arity mismatch, `MiddlewareStack#operations` removal) surfaced as CI failures once Phase 2a's integration specs booted Rails in test.
+
 ## Documentation
 
 Full documentation is available on the [Wiki](https://github.com/antarr/mysql_genius/wiki).

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

@@ -12,8 +12,7 @@ module MysqlGenius
       prompt = params[:prompt].to_s.strip
       return render(json: { error: "Please describe what you want to query." }, status: :unprocessable_entity) if prompt.blank?
 
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
-      service = MysqlGenius::Core::Ai::Suggestion.new(connection, ai_client, ai_config_for_core)
+      service = MysqlGenius::Core::Ai::Suggestion.new(rails_connection, ai_client, ai_config_for_core)
       result = service.call(prompt, queryable_tables)
       sql = sanitize_ai_sql(result["sql"].to_s)
       render(json: { sql: sql, explanation: result["explanation"] })
@@ -33,8 +32,7 @@ module MysqlGenius
         return render(json: { error: "SQL and EXPLAIN output are required." }, status: :unprocessable_entity)
       end
 
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
-      service = MysqlGenius::Core::Ai::Optimization.new(connection, ai_client, ai_config_for_core)
+      service = MysqlGenius::Core::Ai::Optimization.new(rails_connection, ai_client, ai_config_for_core)
       result = service.call(sql, explain_rows, queryable_tables)
       render(json: result)
     rescue StandardError => e
@@ -47,20 +45,7 @@ module MysqlGenius
       sql = params[:sql].to_s.strip
       return render(json: { error: "SQL is required." }, status: :unprocessable_entity) if sql.blank?
 
-      messages = [
-        { role: "system", content: <<~PROMPT },
-          You are a MySQL query explainer. Given a SQL query, explain in plain English:
-          1. What the query does (tables involved, joins, filters, aggregations)
-          2. How data flows through the query
-          3. Any subtle behaviors (implicit type casts, NULL handling in NOT IN, DISTINCT effects, etc.)
-          4. Potential performance concerns visible from the SQL structure alone
-          #{ai_domain_context}
-          Respond with JSON: {"explanation": "your plain-English explanation using markdown formatting"}
-        PROMPT
-        { role: "user", content: sql },
-      ]
-
-      result = ai_client.chat(messages: messages)
+      result = MysqlGenius::Core::Ai::DescribeQuery.new(ai_client, ai_config_for_core).call(sql)
       render(json: result)
     rescue StandardError => e
       render(json: { error: "Explanation failed: #{e.message}" }, status: :unprocessable_entity)
@@ -69,42 +54,7 @@ module MysqlGenius
     def schema_review
       return ai_not_configured unless mysql_genius_config.ai_enabled?
 
-      table = params[:table].to_s.strip
-      connection = ActiveRecord::Base.connection
-
-      tables_to_review = table.present? ? [table] : queryable_tables.first(20)
-      schema_desc = tables_to_review.map do |t|
-        next unless connection.tables.include?(t)
-
-        cols = connection.columns(t).map { |c| "#{c.name} #{c.sql_type}#{" NOT NULL" unless c.null}#{" DEFAULT #{c.default}" if c.default}" }
-        pk = connection.primary_key(t)
-        indexes = connection.indexes(t).map { |idx| "#{"UNIQUE " if idx.unique}INDEX #{idx.name} (#{idx.columns.join(", ")})" }
-        row_count = connection.exec_query("SELECT TABLE_ROWS FROM information_schema.tables WHERE table_schema = #{connection.quote(connection.current_database)} AND table_name = #{connection.quote(t)}").rows.first&.first
-        desc = "Table: #{t} (~#{row_count} rows)\n"
-        desc += "Primary Key: #{pk || "NONE"}\n"
-        desc += "Columns: #{cols.join(", ")}\n"
-        desc += "Indexes: #{indexes.any? ? indexes.join(", ") : "NONE"}"
-        desc
-      end.compact.join("\n\n")
-
-      messages = [
-        { role: "system", content: <<~PROMPT },
-          You are a MySQL schema reviewer for a Ruby on Rails application. Analyze the following schema and identify anti-patterns and improvement opportunities. Look for:
-          - Inappropriate column types (VARCHAR(255) for short values, TEXT where VARCHAR suffices, INT for booleans)
-          - Missing indexes on foreign key columns or frequently filtered columns
-          - Missing NOT NULL constraints where NULLs are unlikely
-          - ENUM columns that should be lookup tables
-          - Missing created_at/updated_at timestamps
-          - Tables without a PRIMARY KEY
-          - Overly wide indexes or redundant indexes
-          - Column naming inconsistencies
-          #{ai_domain_context}
-          Respond with JSON: {"findings": "markdown-formatted findings organized by severity (Critical, Warning, Suggestion). Include specific ALTER TABLE statements where applicable."}
-        PROMPT
-        { role: "user", content: schema_desc },
-      ]
-
-      result = ai_client.chat(messages: messages)
+      result = MysqlGenius::Core::Ai::SchemaReview.new(ai_client, ai_config_for_core, rails_connection).call(params[:table].to_s.strip.presence)
       render(json: result)
     rescue StandardError => e
       render(json: { error: "Schema review failed: #{e.message}" }, status: :unprocessable_entity)
@@ -116,31 +66,7 @@ module MysqlGenius
       sql = params[:sql].to_s.strip
       return render(json: { error: "SQL is required." }, status: :unprocessable_entity) if sql.blank?
 
-      schema = build_schema_for_query(sql)
-
-      messages = [
-        { role: "system", content: <<~PROMPT },
-          You are a MySQL query rewrite expert. Analyze the SQL for anti-patterns and suggest a rewritten version. Look for:
-          - SELECT * when specific columns would suffice
-          - Correlated subqueries that could be JOINs
-          - OR conditions preventing index use (suggest UNION ALL)
-          - LIKE '%prefix' patterns (leading wildcard)
-          - Implicit type conversions in WHERE clauses
-          - NOT IN with NULLable columns (suggest NOT EXISTS)
-          - ORDER BY on non-indexed columns with LIMIT
-          - Unnecessary DISTINCT
-          - Functions on indexed columns in WHERE (e.g., DATE(created_at) instead of range)
-
-          Available schema:
-          #{schema}
-          #{ai_domain_context}
-
-          Respond with JSON: {"original": "the original SQL", "rewritten": "the improved SQL", "changes": "markdown list of each change and why it helps"}
-        PROMPT
-        { role: "user", content: sql },
-      ]
-
-      result = ai_client.chat(messages: messages)
+      result = MysqlGenius::Core::Ai::RewriteQuery.new(ai_client, ai_config_for_core, rails_connection).call(sql)
       render(json: result)
     rescue StandardError => e
       render(json: { error: "Rewrite failed: #{e.message}" }, status: :unprocessable_entity)
@@ -153,33 +79,7 @@ module MysqlGenius
       explain_rows = Array(params[:explain_rows]).map { |row| row.respond_to?(:values) ? row.values : Array(row) }
       return render(json: { error: "SQL and EXPLAIN output are required." }, status: :unprocessable_entity) if sql.blank? || explain_rows.blank?
 
-      connection = ActiveRecord::Base.connection
-      tables_in_query = MysqlGenius::Core::SqlValidator.extract_table_references(sql, connection)
-
-      index_detail = tables_in_query.map do |t|
-        indexes = connection.indexes(t).map { |idx| "#{"UNIQUE " if idx.unique}INDEX #{idx.name} (#{idx.columns.join(", ")})" }
-        stats = connection.exec_query("SELECT INDEX_NAME, COLUMN_NAME, CARDINALITY, SEQ_IN_INDEX FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = #{connection.quote(connection.current_database)} AND TABLE_NAME = #{connection.quote(t)} ORDER BY INDEX_NAME, SEQ_IN_INDEX")
-        cardinality = stats.rows.map { |r| "#{r[0]}.#{r[1]}: cardinality=#{r[2]}" }.join(", ")
-        row_count = connection.exec_query("SELECT TABLE_ROWS FROM information_schema.tables WHERE table_schema = #{connection.quote(connection.current_database)} AND table_name = #{connection.quote(t)}").rows.first&.first
-        "Table: #{t} (~#{row_count} rows)\nIndexes: #{indexes.any? ? indexes.join("; ") : "NONE"}\nCardinality: #{cardinality}"
-      end.join("\n\n")
-
-      messages = [
-        { role: "system", content: <<~PROMPT },
-          You are a MySQL index advisor. Given a query, its EXPLAIN output, and current index/cardinality information, suggest optimal indexes. Consider:
-          - Composite index column ordering (most selective first, or matching query order)
-          - Covering indexes to avoid table lookups
-          - Partial indexes for long string columns
-          - Write-side costs (if this is a high-write table, note the INSERT/UPDATE overhead)
-          - Whether existing indexes could be extended rather than creating new ones
-          #{ai_domain_context}
-
-          Respond with JSON: {"indexes": "markdown-formatted recommendations with exact CREATE INDEX statements, rationale for column ordering, and estimated impact. Include any indexes that should be DROPPED as part of the change."}
-        PROMPT
-        { role: "user", content: "Query:\n#{sql}\n\nEXPLAIN:\n#{explain_rows.map { |r| r.join(" | ") }.join("\n")}\n\nCurrent Indexes:\n#{index_detail}" },
-      ]
-
-      result = ai_client.chat(messages: messages)
+      result = MysqlGenius::Core::Ai::IndexAdvisor.new(ai_client, ai_config_for_core, rails_connection).call(sql, explain_rows)
       render(json: result)
     rescue StandardError => e
       render(json: { error: "Index advisor failed: #{e.message}" }, status: :unprocessable_entity)
@@ -223,6 +123,7 @@ module MysqlGenius
 
       slow_summary = slow_data.first(50).map { |q| "#{q["duration_ms"]}ms @ #{q["timestamp"]}: #{q["sql"].to_s.truncate(150)}" }.join("\n")
       stats_summary = stats.map { |q| "calls=#{q[:calls]} avg=#{q[:avg_ms]}ms total=#{q[:total_ms]}ms exam=#{q[:rows_examined]} sent=#{q[:rows_sent]}: #{q[:sql]}" }.join("\n")
+      domain_ctx = mysql_genius_config.ai_system_context.present? ? "\nDomain context:\n#{mysql_genius_config.ai_system_context}" : ""
 
       messages = [
         { role: "system", content: <<~PROMPT },
@@ -232,7 +133,7 @@ module MysqlGenius
           3. Full table scans (rows_examined >> rows_sent)
           4. Sudden new query patterns that may indicate code changes
           5. Queries creating excessive temp tables or sorts
-          #{ai_domain_context}
+          #{domain_ctx}
 
           Respond with JSON: {"report": "markdown-formatted health report organized by severity. For each finding, explain the issue, affected query, and recommended fix."}
         PROMPT
@@ -294,6 +195,8 @@ module MysqlGenius
         slow_summary = slows.map { |q| "#{q["duration_ms"]}ms: #{q["sql"].to_s.truncate(150)}" }.join("\n")
       end
 
+      domain_ctx = mysql_genius_config.ai_system_context.present? ? "\nDomain context:\n#{mysql_genius_config.ai_system_context}" : ""
+
       messages = [
         { role: "system", content: <<~PROMPT },
           You are a MySQL incident responder. The user is asking "why is the database slow right now?" Analyze the provided data and give a root cause diagnosis. Consider:
@@ -304,7 +207,7 @@ module MysqlGenius
           - Disk I/O saturation
           - Replication lag
           - Unusual query patterns
-          #{ai_domain_context}
+          #{domain_ctx}
 
           Respond with JSON: {"diagnosis": "markdown-formatted root cause analysis. Start with a 1-2 sentence summary, then detailed findings. Include specific actionable steps to resolve the issue."}
         PROMPT
@@ -323,54 +226,7 @@ module MysqlGenius
       migration_sql = params[:migration].to_s.strip
       return render(json: { error: "Migration SQL or Ruby code is required." }, status: :unprocessable_entity) if migration_sql.blank?
 
-      connection = ActiveRecord::Base.connection
-
-      # Try to identify tables mentioned in the migration
-      table_names = migration_sql.scan(/(?:create_table|add_column|remove_column|add_index|remove_index|rename_column|change_column|alter\s+table)\s+[:\"]?(\w+)/i).flatten.uniq
-      table_names += migration_sql.scan(/ALTER\s+TABLE\s+`?(\w+)`?/i).flatten
-
-      table_info = table_names.uniq.map do |t|
-        next unless connection.tables.include?(t)
-
-        row_count = connection.exec_query("SELECT TABLE_ROWS FROM information_schema.tables WHERE table_schema = #{connection.quote(connection.current_database)} AND table_name = #{connection.quote(t)}").rows.first&.first
-        indexes = connection.indexes(t).map { |idx| "#{idx.name} (#{idx.columns.join(", ")})" }
-        "Table: #{t} (~#{row_count} rows, #{indexes.size} indexes)"
-      end.compact.join("\n")
-
-      # Current active queries on those tables
-      active = ""
-      begin
-        results = connection.exec_query(<<~SQL)
-          SELECT DIGEST_TEXT, COUNT_STAR AS calls, ROUND(AVG_TIMER_WAIT / 1000000000, 1) AS avg_ms
-          FROM performance_schema.events_statements_summary_by_digest
-          WHERE SCHEMA_NAME = #{connection.quote(connection.current_database)}
-            AND DIGEST_TEXT IS NOT NULL
-            AND COUNT_STAR > 10
-          ORDER BY COUNT_STAR DESC LIMIT 20
-        SQL
-        matching = results.rows.select { |r| table_names.any? { |t| r[0].to_s.downcase.include?(t.downcase) } }
-        active = matching.map { |r| "calls=#{r[1]} avg=#{r[2]}ms: #{r[0].to_s.truncate(200)}" }.join("\n")
-      rescue ActiveRecord::StatementInvalid
-        # performance_schema may be unavailable
-      end
-
-      messages = [
-        { role: "system", content: <<~PROMPT },
-          You are a MySQL migration risk assessor. Given a Rails migration or DDL, evaluate:
-          1. Will this lock the table? For how long given the row count?
-          2. Is this safe to run during traffic, or does it need a maintenance window?
-          3. Should pt-online-schema-change or gh-ost be used instead?
-          4. Will it break or degrade any of the active queries against this table?
-          5. Are there any data loss risks?
-          6. What is the recommended deployment strategy?
-          #{ai_domain_context}
-
-          Respond with JSON: {"risk_level": "low|medium|high|critical", "assessment": "markdown-formatted risk assessment with specific recommendations and estimated lock duration"}
-        PROMPT
-        { role: "user", content: "Migration:\n#{migration_sql}\n\nAffected Tables:\n#{table_info.presence || "Could not determine"}\n\nActive Queries on These Tables:\n#{active.presence || "None found or performance_schema unavailable"}" },
-      ]
-
-      result = ai_client.chat(messages: messages)
+      result = MysqlGenius::Core::Ai::MigrationRisk.new(ai_client, ai_config_for_core, rails_connection).call(migration_sql)
       render(json: result)
     rescue StandardError => e
       render(json: { error: "Migration risk assessment failed: #{e.message}" }, status: :unprocessable_entity)
@@ -378,6 +234,10 @@ module MysqlGenius
 
     private
 
+    RAILS_DOMAIN_CONTEXT = <<~CTX
+      This is a Ruby on Rails application. Do NOT recommend adding foreign key constraints (FOREIGN KEY / REFERENCES); Rails handles referential integrity at the application layer. DO recommend indexes on foreign key columns for join performance.
+    CTX
+
     def ai_client
       MysqlGenius::Core::Ai::Client.new(ai_config_for_core)
     end
@@ -391,28 +251,12 @@ module MysqlGenius
         model: cfg.ai_model,
         auth_style: cfg.ai_auth_style,
         system_context: cfg.ai_system_context,
+        domain_context: RAILS_DOMAIN_CONTEXT,
       )
     end
 
     def ai_not_configured
       render(json: { error: "AI features are not configured." }, status: :not_found)
     end
-
-    def ai_domain_context
-      parts = []
-      parts << "This is a Ruby on Rails application. Do NOT recommend adding foreign key constraints (FOREIGN KEY / REFERENCES); Rails handles referential integrity at the application layer. DO recommend indexes on foreign key columns for join performance."
-      ctx = mysql_genius_config.ai_system_context
-      parts << "Domain context:\n#{ctx}" if ctx.present?
-      "\n" + parts.join("\n")
-    end
-
-    def build_schema_for_query(sql)
-      connection = ActiveRecord::Base.connection
-      tables = MysqlGenius::Core::SqlValidator.extract_table_references(sql, connection)
-      tables.map do |t|
-        cols = connection.columns(t).map { |c| "#{c.name} (#{c.type})" }
-        "#{t}: #{cols.join(", ")}"
-      end.join("\n")
-    end
   end
 end

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

@@ -5,40 +5,35 @@ module MysqlGenius
     extend ActiveSupport::Concern
 
     def duplicate_indexes
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
       duplicates = MysqlGenius::Core::Analysis::DuplicateIndexes
-        .new(connection, blocked_tables: mysql_genius_config.blocked_tables)
+        .new(rails_connection, blocked_tables: mysql_genius_config.blocked_tables)
         .call
       render(json: duplicates)
     end
 
     def table_sizes
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
-      tables = MysqlGenius::Core::Analysis::TableSizes.new(connection).call
+      tables = MysqlGenius::Core::Analysis::TableSizes.new(rails_connection).call
       render(json: tables)
     end
 
     def query_stats
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
       sort = params[:sort].to_s
       limit = params.fetch(:limit, MysqlGenius::Core::Analysis::QueryStats::MAX_LIMIT).to_i
-      queries = MysqlGenius::Core::Analysis::QueryStats.new(connection).call(sort: sort, limit: limit)
+      queries = MysqlGenius::Core::Analysis::QueryStats.new(rails_connection).call(sort: sort, limit: limit)
       render(json: queries)
     rescue ActiveRecord::StatementInvalid => e
       render(json: { error: "Query statistics require performance_schema to be enabled. #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
     end
 
     def unused_indexes
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
-      indexes = MysqlGenius::Core::Analysis::UnusedIndexes.new(connection).call
+      indexes = MysqlGenius::Core::Analysis::UnusedIndexes.new(rails_connection).call
       render(json: indexes)
     rescue ActiveRecord::StatementInvalid => e
       render(json: { error: "Unused index detection requires performance_schema. #{e.message.split(":").last.strip}" }, status: :unprocessable_entity)
     end
 
     def server_overview
-      connection = MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
-      overview = MysqlGenius::Core::Analysis::ServerOverview.new(connection).call
+      overview = MysqlGenius::Core::Analysis::ServerOverview.new(rails_connection).call
       render(json: overview)
     rescue => e
       render(json: { error: "Failed to load server overview: #{e.message}" }, status: :unprocessable_entity)

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

@@ -12,13 +12,12 @@ module MysqlGenius
         mysql_genius_config.default_row_limit
       end
 
-      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)
+      runner = MysqlGenius::Core::QueryRunner.new(rails_connection, runner_config)
 
       begin
         result = runner.run(sql, row_limit: row_limit)
@@ -48,13 +47,12 @@ module MysqlGenius
       sql = params[:sql].to_s.strip
       skip_validation = params[:from_slow_query] == "true"
 
-      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)
+      explainer = MysqlGenius::Core::QueryExplainer.new(rails_connection, runner_config)
 
       result = explainer.explain(sql, skip_validation: skip_validation)
       render(json: { columns: result.columns, rows: result.rows })

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MysqlGenius
+  module SharedViewHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :path_for, :render_partial
+    end
+
+    # URL path helper for shared templates.
+    #   path_for(:execute) # => "/mysql_genius/execute" (from engine route helpers)
+    def path_for(name)
+      mysql_genius.public_send("#{name}_path")
+    end
+
+    # Partial renderer for shared templates.
+    #   render_partial(:tab_dashboard) # => view_context.render partial: "mysql_genius/queries/tab_dashboard"
+    def render_partial(name)
+      view_context.render(partial: "mysql_genius/queries/#{name}")
+    end
+  end
+end

data/app/controllers/mysql_genius/base_controller.rb

@@ -16,5 +16,14 @@ module MysqlGenius
     def mysql_genius_config
       MysqlGenius.configuration
     end
+
+    # Wraps ActiveRecord::Base.connection in a Core::Connection::ActiveRecordAdapter.
+    # Every controller action that delegates to a Core::* service calls this
+    # instead of instantiating the adapter inline. Shared across all concerns
+    # (QueryExecution, DatabaseAnalysis, AiFeatures) via BaseController's
+    # private method lookup.
+    def rails_connection
+      MysqlGenius::Core::Connection::ActiveRecordAdapter.new(ActiveRecord::Base.connection)
+    end
   end
 end

data/app/controllers/mysql_genius/queries_controller.rb

@@ -5,6 +5,7 @@ module MysqlGenius
     include QueryExecution
     include DatabaseAnalysis
     include AiFeatures
+    include SharedViewHelpers
 
     def index
       @featured_tables = if mysql_genius_config.featured_tables.any?
@@ -14,23 +15,24 @@ module MysqlGenius
       end
       @all_tables = queryable_tables.sort
       @ai_enabled = mysql_genius_config.ai_enabled?
+      @framework_version_major = Rails::VERSION::MAJOR
+      @framework_version_minor = Rails::VERSION::MINOR
+      render("mysql_genius/queries/dashboard")
     end
 
     def columns
-      table = params[:table]
-      if mysql_genius_config.blocked_tables.include?(table)
-        return render(json: { error: "Table '#{table}' is not available for querying." }, status: :forbidden)
+      result = MysqlGenius::Core::Analysis::Columns.new(
+        rails_connection,
+        blocked_tables: mysql_genius_config.blocked_tables,
+        masked_column_patterns: mysql_genius_config.masked_column_patterns,
+        default_columns: mysql_genius_config.default_columns,
+      ).call(table: params[:table])
+
+      case result.status
+      when :ok        then render(json: result.columns)
+      when :blocked   then render(json: { error: result.error_message }, status: :forbidden)
+      when :not_found then render(json: { error: result.error_message }, status: :not_found)
       end
-
-      unless ActiveRecord::Base.connection.tables.include?(table)
-        return render(json: { error: "Table '#{table}' does not exist." }, status: :not_found)
-      end
-
-      defaults = mysql_genius_config.default_columns[table] || []
-      cols = ActiveRecord::Base.connection.columns(table).reject { |c| masked_column?(c.name) }.map do |c|
-        { name: c.name, type: c.type.to_s, default: defaults.empty? || defaults.include?(c.name) }
-      end
-      render(json: cols)
     end
 
     def slow_queries
@@ -57,15 +59,5 @@ module MysqlGenius
     def queryable_tables
       ActiveRecord::Base.connection.tables - mysql_genius_config.blocked_tables
     end
-
-    # Delegates to Core::SqlValidator's 2-arg class method. A bare
-    # `masked_column?(name)` call survives on line 30 because this helper
-    # reintroduces the 1-arg instance method the controller's `columns`
-    # action depends on. Without this helper, `columns` raises NoMethodError
-    # at runtime (Phase 1b regression — Core::SqlValidator.masked_column?
-    # became a 2-arg class method but the call site wasn't updated).
-    def masked_column?(name)
-      MysqlGenius::Core::SqlValidator.masked_column?(name, mysql_genius_config.masked_column_patterns)
-    end
   end
 end

data/lib/mysql_genius/engine.rb

@@ -4,6 +4,10 @@ module MysqlGenius
   class Engine < ::Rails::Engine
     isolate_namespace MysqlGenius
 
+    initializer "mysql_genius.register_core_views", before: :add_view_paths do
+      paths["app/views"] << MysqlGenius::Core.views_path
+    end
+
     config.after_initialize do
       if MysqlGenius.configuration.redis_url.present?
         require "mysql_genius/slow_query_monitor"

data/lib/mysql_genius/version.rb

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

data/mysql_genius.gemspec

@@ -20,7 +20,6 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.6.0"
 
   spec.metadata["homepage_uri"]    = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"]   = "#{spec.homepage}/blob/main/CHANGELOG.md"
 
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
@@ -30,7 +29,7 @@ Gem::Specification.new do |spec|
   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")
+  spec.add_dependency("activerecord", ">= 6.0", "< 9")
+  spec.add_dependency("mysql_genius-core", "~> 0.6.0")
+  spec.add_dependency("railties", ">= 6.0", "< 9")
 end