ask-ruby-harness 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 411e139b4a5cfe5e017a748753c36a1f811a45f719e2245c7789267d4fe9f476
-  data.tar.gz: bd78de0520de347c8ffb675c7c704187c98fc7971b3b4a30770c227479adf7f3
+  metadata.gz: d70bd6e8f4bbf2d01ad1e3b68a49ca668edb25730dc7473690815a4416de02bd
+  data.tar.gz: c3e5f670a81444bc2022a32d57ea64f0ab09435b6d49a2e31333607b0d758850
 SHA512:
-  metadata.gz: 4010a7f88a99c289dc68a1bbb40e7b8b829ac794b2a9daf609558128dad5b809f1a6900fae0d8d4c46d795ab69aa5802aa4cfde361256601c913d893f2551000
-  data.tar.gz: 6c0362992da2df7e54e0191fbc494c35c90641d538c9f2f7ea63e58b8a33a5d4a9248f32ee58def32d5db09547c83887dd598f7dbe524fc98b19a29c04a6f4bb
+  metadata.gz: 5f973f3223d742de9f530bd2eaf91f70ef5ed2e6ec0376a5103d9ea6683401bc5002934dd1aa5ffa0731bf4e6fffe387d4f11a4e180258d61439bfbc7955bd73
+  data.tar.gz: b8326c07280c08a863073d8c01db0e90688799eef058dc63a5ecb44d268c6f153fb70de3db28795c2265a10602a7ad3a3dcc0cb609eec0aa007ee448895bba96

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [0.3.0] — 2026-08-10
+
+### Added
+
+- **Multi-database support in `QueryDatabase`** — new `database:` param to
+  target any named database: a `config/database.yml` key (resolved first
+  through the host app's own configurations registry, so Rails multi-DB
+  apps work with credential-resolved configs) or a full connection URL.
+  The result reports which database was queried. Write guards apply to all
+  databases.
+
+### Fixed
+
+- **The gem now requires `active_record` itself** — previously the harness
+  only loaded AR when the host did, so standalone processes (the MCP
+  server) failed `ASK_DATABASE_URL` connections with "uninitialized
+  constant ActiveRecord".
+
 ## [0.2.1] — 2026-08-10
 
 ### Fixed

data/lib/ask/ruby/harness/tools/query_database.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "time"
+require "uri"
 
 module Ask
   module Ruby
@@ -8,14 +9,18 @@ module Ask
       module Tools
         class QueryDatabase < Ask::Ruby::Harness::Tool
           description "Run a read-only SQL query against the application database. " \
-                       "Returns columns and rows. Only SELECT queries are allowed in production."
+                       "Returns columns and rows. Only SELECT queries are allowed in production. " \
+                       "Multi-database apps can target a named database (a config/database.yml " \
+                       "key or a full connection URL) with the database param."
 
           param :sql,   type: :string, desc: "SQL query (SELECT only in production)", required: true
           param :limit, type: :integer, desc: "Max rows to return (default 50)", required: false
+          param :database, type: :string, desc: "Named database from config/database.yml or a full connection URL (default: primary)", required: false
 
           WRITE_STATEMENTS = /\A\s*(INSERT|UPDATE|DELETE|DROP|TRUNCATE|ALTER|CREATE|GRANT|REVOKE)\b/i
+          URL_PATTERN = %r{\A[a-z][a-z0-9+]*://}
 
-          def execute(sql:, limit: 50)
+          def execute(sql:, limit: 50, database: nil)
             sql = sql.strip
 
             if WRITE_STATEMENTS.match?(sql)
@@ -30,38 +35,86 @@ module Ask
               )
             end
 
-            unless Ask::Ruby::Harness.database_configured?
-              Ask::Ruby::Harness.connect_database!
-            end
-            unless Ask::Ruby::Harness.database_configured?
-              return Ask::Result.failure(
-                "Database not connected. Set ASK_DATABASE_URL or provide a config/database.yml."
-              )
-            end
+            pool = resolve_pool(database)
+            return pool if pool.is_a?(Ask::Result)
 
-            pool = ActiveRecord::Base.connection_pool
-            pool.with_connection do |conn|
+            result = pool.with_connection do |conn|
               limited_sql = sql.match?(/\bLIMIT\b/i) ? sql : "#{sql.chomp(';')} LIMIT #{limit.to_i}"
-              result = conn.exec_query(limited_sql)
-              columns = result.columns
-              rows = result.rows.first(limit.to_i).map { |row| build_row(row, columns) }
+              query_result = conn.exec_query(limited_sql)
+              columns = query_result.columns
+              rows = query_result.rows.first(limit.to_i).map { |row| build_row(row, columns) }
               {
                 columns: columns,
                 rows: rows,
                 count: rows.size,
-                truncated: result.rows.size > limit.to_i
+                truncated: query_result.rows.size > limit.to_i
               }
             end
+            result.merge(database: resolved_database_name(database))
           rescue ActiveRecord::StatementInvalid => e
             Ask::Result.failure("SQL error: #{e.message}")
           rescue ActiveRecord::ConnectionNotEstablished => e
             Ask::Result.failure(
-              "Database not connected: #{e.message}. Set ASK_DATABASE_URL or config/database.yml."
+              "Database not connected: #{e.message}. Set ASK_DATABASE_URL or provide a config/database.yml."
             )
           end
 
           private
 
+          # Resolve the connection pool for the target database:
+          #   - nil/"primary" → the default pool (connecting standalone when needed)
+          #   - a URL        → a pool established from that URL
+          #   - a name       → an existing pool (Rails multi-DB), else a pool
+          #                    established from config/database.yml
+          def resolve_pool(database)
+            if database.nil? || database == "primary"
+              unless Ask::Ruby::Harness.database_configured?
+                Ask::Ruby::Harness.connect_database!
+              end
+              unless Ask::Ruby::Harness.database_configured?
+                return Ask::Result.failure(
+                  "Database not connected. Set ASK_DATABASE_URL or provide a config/database.yml."
+                )
+              end
+              return ActiveRecord::Base.connection_pool
+            end
+
+            name = database.to_s
+            pool = ActiveRecord::Base.connection_handler.retrieve_connection_pool(name)
+            return pool if pool
+
+            config = url_config(database) || Ask::Ruby::Harness.database_config_for(name)
+            unless config
+              return Ask::Result.failure(
+                "Database '#{database}' not found. Add it to config/database.yml or pass a full connection URL."
+              )
+            end
+
+            owner = name.match?(URL_PATTERN) ? "ask_url_#{name.hash.abs}" : name.to_sym
+            ActiveRecord::Base.connection_handler.establish_connection(config, owner_name: owner)
+            ActiveRecord::Base.connection_handler.retrieve_connection_pool(owner.to_s) ||
+              Ask::Result.failure("Could not connect to database '#{database}'.")
+          end
+
+          def url_config(database)
+            database if database.to_s.match?(URL_PATTERN)
+          end
+
+          # What to report back as `database`: the config key as passed, or
+          # the database name parsed from a URL (never the full URL — it may
+          # carry credentials).
+          def resolved_database_name(database)
+            return "primary" if database.nil? || database == "primary"
+            return database unless database.to_s.match?(URL_PATTERN)
+
+            uri = URI.parse(database)
+            name = uri.path.to_s.delete_prefix("/")
+            name = File.basename(name) if name.include?("/")
+            name.empty? ? uri.host.to_s : name
+          rescue URI::InvalidURIError
+            database
+          end
+
           def build_row(row, columns)
             columns.each_with_index.each_with_object({}) do |(col, i), hash|
               value = row[i]

data/lib/ask/ruby/harness/version.rb

@@ -3,7 +3,7 @@
 module Ask
   module Ruby
     module Harness
-      VERSION = "0.2.1"
+      VERSION = "0.3.0"
     end
   end
 end

data/lib/ask/ruby/harness.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "active_record"
 require "ask/agent"
 require "time"
 require "yaml"
@@ -93,6 +94,22 @@ module Ask
           false
         end
 
+        # Config for a NAMED database. Resolution order:
+        #   1. the host app's own configurations registry (Rails multi-DB —
+        #      resolves credentials/ENV for us),
+        #   2. config/database.yml, the environment section's key.
+        def database_config_for(name)
+          name = name.to_s
+          if ActiveRecord::Base.respond_to?(:configurations)
+            db = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
+            return sanitize_database_config(db.configuration_hash.transform_keys(&:to_s)) if db
+          end
+
+          section = database_yaml_section
+          config = section[name] if section.is_a?(Hash) && section[name].is_a?(Hash)
+          sanitize_database_config(config)
+        end
+
         private
 
         def build_environment_hooks
@@ -177,17 +194,30 @@ module Ask
           tools
         end
 
+        # Config for the primary database: the `primary` section (Rails
+        # multi-DB style) or the whole environment section of database.yml.
         def database_config_from_yaml
+          section = database_yaml_section
+          config = section["primary"].is_a?(Hash) ? section["primary"] : section
+          sanitize_database_config(config)
+        end
+
+        private
+
+        def database_yaml_section
           path = app_root.join("config", "database.yml")
           return nil unless path.exist?
 
           yaml = YAML.safe_load(path.read, aliases: true) || {}
-          section = yaml[env] || yaml["development"] || {}
-          # Rails-style multi-database config nests the primary under a key.
-          section = section["primary"] if section.is_a?(Hash) && section["primary"].is_a?(Hash)
-          return nil unless section.is_a?(Hash)
+          yaml[env] || yaml["development"] || {}
+        rescue Psych::Exception
+          nil
+        end
 
-          config = section.slice(*Configuration::DATABASE_CONFIG_KEYS)
+        def sanitize_database_config(config)
+          return nil unless config.is_a?(Hash)
+
+          config = config.slice(*Configuration::DATABASE_CONFIG_KEYS)
           # Resolve relative sqlite paths against app_root, like Rails does —
           # the harness may run with a different cwd than the project root.
           if config["adapter"].to_s.include?("sqlite") &&
@@ -195,8 +225,6 @@ module Ask
             config["database"] = app_root.join(config["database"]).to_s
           end
           config.presence
-        rescue Psych::Exception
-          nil
         end
 
         def default_system_prompt

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-ruby-harness
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kaka Ruto