sql_genius 0.9.0

data/lib/sql_genius/core/ai/describe_query.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Builds and sends a "describe this query" prompt to Core::Ai::Client.
+      # Pure function of SQL + config.domain_context — no connection lookup.
+      #
+      # Extracted from app/controllers/concerns/sql_genius/ai_features.rb
+      # in Phase 2a.
+      class DescribeQuery
+        def initialize(client, config)
+          @client = client
+          @config = config
+        end
+
+        def call(sql)
+          messages = [
+            { role: "system", content: system_prompt },
+            { role: "user",   content: sql },
+          ]
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def system_prompt
+          <<~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
+            #{@config.domain_context}
+            Respond with JSON: {"explanation": "your plain-English explanation using markdown formatting"}
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/dialect_hints.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Snippets injected into AI system prompts so the model generates SQL in
+      # the right dialect. Without these, prompts hardcode "MySQL" and tell
+      # the model to use backticks — which produces broken SQL on PostgreSQL
+      # (PG uses double quotes for identifiers and has no backtick syntax).
+      module DialectHints
+        extend self
+
+        # Display name suitable for "You are a SQL assistant for a #{name_for}
+        # database." prompts.
+        def name_for(connection)
+          case connection.server_version.dialect
+          when :postgresql then "PostgreSQL"
+          else "MySQL/MariaDB"
+          end
+        end
+
+        # Identifier-quoting rule string for inclusion in a numbered Rules
+        # list in a prompt. PG uses double quotes; MySQL/MariaDB uses
+        # backticks.
+        def identifier_quoting_rule(connection)
+          if connection.server_version.postgresql?
+            %(Use double quotes ("col_name") for case-sensitive identifiers; otherwise leave them bare.)
+          else
+            "Use backticks (`col_name`) for table and column names."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/index_advisor.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      class IndexAdvisor
+        def initialize(client, config, connection)
+          @client = client
+          @config = config
+          @connection = connection
+        end
+
+        def call(sql, explain_rows)
+          tables = SqlValidator.extract_table_references(sql, @connection)
+          schema = SchemaContextBuilder.new(@connection).call(tables, detail: :with_cardinality)
+          explain_text = explain_rows.map { |row| row.join(" | ") }.join("\n")
+
+          messages = [
+            { role: "system", content: system_prompt },
+            { role: "user",   content: "Query:\n#{sql}\n\nEXPLAIN:\n#{explain_text}\n\nSchema:\n#{schema}" },
+          ]
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def system_prompt
+          <<~PROMPT
+            You are a #{DialectHints.name_for(@connection)} 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
+            #{@config.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
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/index_planner.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      class IndexPlanner
+        def initialize(client, config, connection)
+          @client = client
+          @config = config
+          @connection = connection
+        end
+
+        def call(tables = nil)
+          target_tables = resolve_tables(tables)
+          return { "plan" => "No tables found to analyze." } if target_tables.empty?
+
+          unused = Analysis::UnusedIndexes.new(@connection).call.indexes
+          duplicates = Analysis::DuplicateIndexes.new(@connection, blocked_tables: []).call
+          schema = SchemaContextBuilder.new(@connection).call(target_tables, detail: :with_cardinality)
+
+          index_map = target_tables.to_h do |table|
+            [table, @connection.indexes_for(table).map do |idx|
+              "#{"UNIQUE " if idx.unique}INDEX #{idx.name} (#{idx.columns.join(", ")})"
+            end,]
+          end
+
+          messages = [
+            { role: "system", content: system_prompt },
+            { role: "user",   content: user_prompt(schema, unused, duplicates, index_map) },
+          ]
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def resolve_tables(tables)
+          list = Array(tables).reject { |t| t.to_s.empty? }
+          return list unless list.empty?
+
+          top_tables_by_size
+        end
+
+        def top_tables_by_size
+          db = @connection.current_database
+          result = @connection.exec_query(
+            "SELECT table_name FROM information_schema.tables " \
+              "WHERE table_schema = #{@connection.quote(db)} AND table_type = 'BASE TABLE' " \
+              "ORDER BY (data_length + index_length) DESC LIMIT 10",
+          )
+          result.rows.map(&:first)
+        rescue StandardError
+          @connection.tables.first(10)
+        end
+
+        def user_prompt(schema, unused, duplicates, index_map)
+          parts = ["Schema with cardinality:\n#{schema}"]
+
+          if unused.any?
+            unused_text = unused.map { |u| "#{u[:table]}.#{u[:index_name]} (reads=#{u[:reads]}, writes=#{u[:writes]})" }
+            parts << "Unused indexes (zero reads):\n#{unused_text.join("\n")}"
+          end
+
+          if duplicates.any?
+            dup_text = duplicates.map do |d|
+              "#{d[:table]}: #{d[:duplicate_index]} (#{d[:duplicate_columns].join(", ")}) covered by #{d[:covered_by_index]} (#{d[:covered_by_columns].join(", ")})"
+            end
+            parts << "Duplicate indexes:\n#{dup_text.join("\n")}"
+          end
+
+          index_summary = index_map.map { |table, idxs| "#{table}: #{idxs.any? ? idxs.join("; ") : "NONE"}" }
+          parts << "Current indexes per table:\n#{index_summary.join("\n")}"
+
+          parts.join("\n\n")
+        end
+
+        def system_prompt
+          <<~PROMPT
+            You are a #{DialectHints.name_for(@connection)} index consolidation planner. Given schema information, unused indexes, duplicate indexes, and current index listings, produce a consolidated optimization plan. For each recommendation:
+            - DROP redundant or unused indexes using #{DialectHints.name_for(@connection)} syntax (e.g. `ALTER TABLE t DROP INDEX i;` on MySQL/MariaDB, `DROP INDEX "i";` on PostgreSQL)
+            - MERGE overlapping indexes into composites where beneficial
+            - KEEP indexes that are actively used and well-structured
+            - ADD new composite indexes where query patterns suggest benefit
+            - Provide rationale for each change and estimated impact on read/write performance
+            #{@config.domain_context}
+            Respond with JSON: {"plan": "markdown with dialect-appropriate DROP INDEX / CREATE INDEX statements, rationale for each change, and estimated impact"}
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/innodb_interpreter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Interprets SHOW ENGINE INNODB STATUS output in plain English.
+      # Combines the raw InnoDB status text with key metrics from
+      # ServerOverview to give the LLM full context for its analysis.
+      class InnodbInterpreter
+        MAX_STATUS_LENGTH = 4000
+
+        def initialize(client, config, connection)
+          @client = client
+          @config = config
+          @connection = connection
+        end
+
+        def call
+          if @connection.server_version.postgresql?
+            raise Core::UnsupportedDialect.for_postgresql("InnoDB Health Interpreter")
+          end
+
+          status_text = fetch_innodb_status
+          metrics = fetch_innodb_metrics
+
+          messages = [
+            { role: "system", content: system_prompt },
+            { role: "user",   content: user_prompt(status_text, metrics) },
+          ]
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def fetch_innodb_status
+          result = @connection.exec_query("SHOW ENGINE INNODB STATUS")
+          text = result.rows.first&.dig(2).to_s
+          text.length > MAX_STATUS_LENGTH ? text[0, MAX_STATUS_LENGTH] : text
+        end
+
+        def fetch_innodb_metrics
+          overview = Analysis::ServerOverview.new(@connection).call
+          overview[:innodb]
+        end
+
+        def system_prompt
+          <<~PROMPT
+            You are a MySQL InnoDB internals expert. Analyze the SHOW ENGINE INNODB STATUS output and the supplementary metrics below. Provide a plain-English interpretation organized by these sections:
+            - **Deadlocks**: recent deadlock information, lock wait chains, affected transactions
+            - **Transaction History**: history list length, purge lag, long-running transactions
+            - **Buffer Pool**: hit rate, dirty page ratio, free pages, eviction pressure
+            - **I/O**: pending reads/writes, log sequence numbers, checkpoint age, log sizing adequacy
+            - **Semaphores**: mutex/rw-lock waits, spin rounds, OS waits indicating contention
+
+            For each section, explain what the numbers mean in practical terms and recommend specific actions if problems are detected.
+            #{@config.domain_context}
+            Respond with JSON: {"findings": "markdown analysis organized by: Deadlocks, Transaction History, Buffer Pool, I/O, Semaphores. Each section should include current state assessment, risk level, and actionable recommendations."}
+          PROMPT
+        end
+
+        def user_prompt(status_text, metrics)
+          lines = ["== SHOW ENGINE INNODB STATUS =="]
+          lines << status_text
+          lines << ""
+          lines << "== InnoDB Metrics Summary =="
+          lines << "Buffer Pool Size: #{metrics[:buffer_pool_mb]} MB"
+          lines << "Buffer Pool Hit Rate: #{metrics[:buffer_pool_hit_rate]}%"
+          lines << "Dirty Pages: #{metrics[:buffer_pool_pages_dirty]}"
+          lines << "Free Pages: #{metrics[:buffer_pool_pages_free]}"
+          lines << "Total Pages: #{metrics[:buffer_pool_pages_total]}"
+          lines << "Row Lock Waits: #{metrics[:row_lock_waits]}"
+          lines << "Row Lock Time (ms): #{metrics[:row_lock_time_ms]}"
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/migration_risk.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      class MigrationRisk
+        def initialize(client, config, connection)
+          @client = client
+          @config = config
+          @connection = connection
+        end
+
+        def call(migration_sql)
+          tables = extract_table_names(migration_sql)
+          schema = SchemaContextBuilder.new(@connection).call(tables, detail: :basic)
+          schema_text = schema.to_s.empty? ? "Could not determine" : schema
+
+          messages = [
+            { role: "system", content: system_prompt },
+            { role: "user",   content: "Migration:\n#{migration_sql}\n\nAffected Tables:\n#{schema_text}" },
+          ]
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def extract_table_names(migration_sql)
+          # Match Rails migration helpers and raw SQL ALTER TABLE statements.
+          rails_matches = migration_sql.scan(/(?:create_table|add_column|remove_column|add_index|remove_index|rename_column|change_column|alter\s+table)\s+[:"]?(\w+)/i).flatten
+          sql_matches   = migration_sql.scan(/ALTER\s+TABLE\s+`?(\w+)`?/i).flatten
+          (rails_matches + sql_matches).uniq
+        end
+
+        def system_prompt
+          <<~PROMPT
+            You are a #{DialectHints.name_for(@connection)} 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?
+            #{@config.domain_context}
+
+            Respond with JSON: {"risk_level": "low|medium|high|critical", "assessment": "markdown-formatted risk assessment with specific recommendations and estimated lock duration"}
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/optimization.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Analyses a SQL query + its EXPLAIN output and asks the AI client
+      # for optimization suggestions.
+      #
+      # Construct with:
+      #   connection - a Core::Connection implementation
+      #   client     - a Core::Ai::Client
+      #   config     - the Core::Ai::Config
+      #
+      # Call:
+      #   .call(sql, explain_rows, allowed_tables)
+      #     explain_rows - Array of arrays OR a pre-formatted String
+      #     -> Hash with "suggestions" key
+      class Optimization
+        def initialize(connection, client, config)
+          @connection = connection
+          @client = client
+          @config = config
+        end
+
+        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) },
+          ]
+
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def system_prompt(schema_description)
+          <<~PROMPT
+            You are a #{DialectHints.name_for(@connection)} 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)
+          allowed_tables.map do |table|
+            next unless @connection.tables.include?(table)
+
+            columns = @connection.columns_for(table).map { |c| "#{c.name} (#{c.type})" }
+            indexes = @connection.indexes_for(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
+  end
+end

data/lib/sql_genius/core/ai/pattern_grouper.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Groups slow queries by shared root cause so a single fix can improve
+      # multiple queries at once. Pulls high-cost statements from
+      # performance_schema, extracts referenced tables, builds schema context,
+      # and asks the LLM to cluster queries by underlying issue.
+      #
+      # Construct with:
+      #   connection - a Core::Connection implementation
+      #   client     - a Core::Ai::Client
+      #   config     - the Core::Ai::Config
+      #
+      # Call:
+      #   .call() -> Hash with "groups" key containing markdown analysis
+      class PatternGrouper
+        QUERY_LIMIT = 30
+        ROWS_RATIO_THRESHOLD = 10
+        AVG_TIME_THRESHOLD = 50
+
+        def initialize(connection, client, config)
+          @connection = connection
+          @client = client
+          @config = config
+        end
+
+        def call
+          all_stats = Analysis::QueryStats.new(@connection).call(sort: "total_time", limit: QUERY_LIMIT)
+          high_cost = all_stats.select { |s| s[:rows_ratio] > ROWS_RATIO_THRESHOLD || s[:avg_time_ms] > AVG_TIME_THRESHOLD }
+          return { "groups" => "No high-cost queries found to analyze." } if high_cost.empty?
+
+          tables = extract_tables(high_cost)
+          schema = tables.any? ? SchemaContextBuilder.new(@connection).call(tables, detail: :basic) : ""
+
+          messages = [
+            { role: "system", content: system_prompt },
+            { role: "user",   content: user_prompt(high_cost, schema) },
+          ]
+
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def extract_tables(stats)
+          stats.flat_map { |s| SqlValidator.extract_table_references(s[:sql], @connection) }.uniq
+        end
+
+        def system_prompt
+          prompt = <<~PROMPT
+            You are a #{DialectHints.name_for(@connection)} performance analyst specializing in root-cause analysis.
+          PROMPT
+
+          if @config.domain_context && !@config.domain_context.empty?
+            prompt += <<~PROMPT
+
+              Domain context:
+              #{@config.domain_context}
+            PROMPT
+          end
+
+          prompt += <<~PROMPT
+
+            Given a set of high-cost queries and the schema they reference, group them by shared root cause.
+            For each group provide:
+            1. The shared root cause (e.g., missing index, full table scan, implicit type conversion)
+            2. The affected queries (numbered)
+            3. A single fix that addresses all queries in the group (with exact SQL: CREATE INDEX, ALTER TABLE, etc.)
+            4. Estimated performance impact
+
+            Respond with JSON: {"groups": "markdown with each group showing: the shared root cause, affected queries (numbered), the single fix that addresses all of them (with exact SQL), and estimated impact"}
+          PROMPT
+
+          prompt
+        end
+
+        def user_prompt(stats, schema)
+          formatted = stats.map.with_index(1) do |s, i|
+            "#{i}. SQL: #{s[:sql]}\n   " \
+              "calls=#{s[:calls]}, avg_time_ms=#{s[:avg_time_ms]}, " \
+              "rows_ratio=#{s[:rows_ratio]}, rows_examined=#{s[:rows_examined]}, " \
+              "tmp_disk_tables=#{s[:tmp_disk_tables]}"
+          end.join("\n")
+
+          parts = ["High-cost queries (rows_ratio > #{ROWS_RATIO_THRESHOLD} OR avg_time_ms > #{AVG_TIME_THRESHOLD}):\n\n#{formatted}"]
+          parts << "Schema context:\n#{schema}" unless schema.empty?
+          parts.join("\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/rewrite_query.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Suggests a rewritten version of a SQL query based on the schema
+      # context of the tables it references.
+      class RewriteQuery
+        def initialize(client, config, connection)
+          @client = client
+          @config = config
+          @connection = connection
+        end
+
+        def call(sql)
+          tables = SqlValidator.extract_table_references(sql, @connection)
+          schema = SchemaContextBuilder.new(@connection).call(tables, detail: :basic)
+
+          messages = [
+            { role: "system", content: system_prompt(schema) },
+            { role: "user",   content: sql },
+          ]
+          @client.chat(messages: messages)
+        end
+
+        private
+
+        def system_prompt(schema)
+          <<~PROMPT
+            You are a #{DialectHints.name_for(@connection)} 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}
+            #{@config.domain_context}
+
+            Respond with JSON: {"original": "the original SQL", "rewritten": "the improved SQL", "changes": "markdown list of each change and why it helps"}
+          PROMPT
+        end
+      end
+    end
+  end
+end

data/lib/sql_genius/core/ai/schema_context_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module SqlGenius
+  module Core
+    module Ai
+      # Builds formatted schema-description strings for AI prompt context.
+      # Used by SchemaReview, RewriteQuery, IndexAdvisor, and MigrationRisk.
+      #
+      # Consolidates the ~10 lines of schema description logic that were
+      # duplicated across 4 AI features in the Rails adapter's
+      # app/controllers/concerns/sql_genius/ai_features.rb.
+      class SchemaContextBuilder
+        def initialize(connection)
+          @connection = connection
+        end
+
+        # Returns a formatted multi-line string describing the given tables.
+        #
+        # detail:
+        #   :basic             — name, row count, primary key, columns, indexes
+        #   :with_cardinality  — adds information_schema.STATISTICS cardinality per index
+        def call(tables, detail: :basic)
+          Array(tables).filter_map { |t| describe_table(t, detail: detail) }.join("\n\n")
+        end
+
+        private
+
+        def describe_table(table, detail:)
+          return unless @connection.tables.include?(table)
+
+          cols = @connection.columns_for(table).map do |c|
+            parts = ["#{c.name} #{c.sql_type}"]
+            parts << "NOT NULL" unless c.null
+            parts << "DEFAULT #{c.default}" if c.default
+            parts.join(" ")
+          end
+
+          pk = @connection.primary_key(table)
+          indexes = @connection.indexes_for(table).map do |idx|
+            "#{"UNIQUE " if idx.unique}INDEX #{idx.name} (#{idx.columns.join(", ")})"
+          end
+
+          row_count = fetch_row_count(table)
+
+          parts = [
+            "Table: #{table} (~#{row_count || "unknown"} rows)",
+            "Primary Key: #{pk || "NONE"}",
+            "Columns: #{cols.join(", ")}",
+            "Indexes: #{indexes.any? ? indexes.join(", ") : "NONE"}",
+          ]
+
+          parts << index_cardinality(table) if detail == :with_cardinality
+
+          parts.join("\n")
+        end
+
+        def fetch_row_count(table)
+          sql = "SELECT TABLE_ROWS FROM information_schema.tables " \
+            "WHERE table_schema = #{@connection.quote(@connection.current_database)} " \
+            "AND table_name = #{@connection.quote(table)}"
+          result = @connection.exec_query(sql)
+          result.rows.first&.first
+        rescue StandardError
+          nil
+        end
+
+        def index_cardinality(table)
+          sql = "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(table)} " \
+            "ORDER BY INDEX_NAME, SEQ_IN_INDEX"
+          result = @connection.exec_query(sql)
+          stats = result.rows.map { |r| "#{r[0]}.#{r[1]}: cardinality=#{r[2]}" }
+          "Cardinality: #{stats.join(", ")}"
+        rescue StandardError
+          "Cardinality: (unavailable)"
+        end
+      end
+    end
+  end
+end