ask-ruby-harness 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb7b07e97747d9737683a53429df81442e810b0ff9825724a02e64c49bb49c0b
-  data.tar.gz: 27b471f9c55911b41636bd3e81d0ea68fc4d168322fffdfaea387211fc58c13d
+  metadata.gz: d70bd6e8f4bbf2d01ad1e3b68a49ca668edb25730dc7473690815a4416de02bd
+  data.tar.gz: c3e5f670a81444bc2022a32d57ea64f0ab09435b6d49a2e31333607b0d758850
 SHA512:
-  metadata.gz: 943ae9fcc4698ff7a6c79feba5d93f30b31975417c6355a38394e146308545ecef270ad70a0675addd2929361c8043fbe8bc6f24b6e439f416fa689e4b5b0861
-  data.tar.gz: ae876247273fa9e6936d0f817ac42f6b57c250abdc4fd7671403a7c289f9da0b03d20b7fb48b6685d7f168db854017a5790f2130430e20f6240b22ae79d477ff
+  metadata.gz: 5f973f3223d742de9f530bd2eaf91f70ef5ed2e6ec0376a5103d9ea6683401bc5002934dd1aa5ffa0731bf4e6fffe387d4f11a4e180258d61439bfbc7955bd73
+  data.tar.gz: b8326c07280c08a863073d8c01db0e90688799eef058dc63a5ecb44d268c6f153fb70de3db28795c2265a10602a7ad3a3dcc0cb609eec0aa007ee448895bba96

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## [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
+
+- **Standalone DB connection guard** — `QueryDatabase` now checks whether a
+  connection spec is *defined* (pool presence) instead of `connected?`
+  (which stays false until the first checkout), so `establish_connection`
+  from `ASK_DATABASE_URL`/`database.yml` is actually honored.
+- **Relative sqlite paths in `database.yml`** — resolved against the app
+  root (like Rails does) instead of the harness's cwd.
+
 ## [0.2.0] — 2026-08-10
 
 ### Added

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_connected?
-              Ask::Ruby::Harness.connect_database!
-            end
-            unless Ask::Ruby::Harness.database_connected?
-              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.0"
+      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"
@@ -72,7 +73,7 @@ module Ask
         #
         # Connection sources, in order: ASK_DATABASE_URL, config/database.yml.
         def connect_database!
-          return if database_connected?
+          return if database_configured?
 
           config = ENV["ASK_DATABASE_URL"] || database_config_from_yaml
           ActiveRecord::Base.establish_connection(config) if config
@@ -80,8 +81,33 @@ module Ask
           warn "[ask-ruby-harness] database connect failed: #{e.message}"
         end
 
-        def database_connected?
-          defined?(ActiveRecord::Base) && ActiveRecord::Base.connected?
+        # Whether a connection spec is defined. Uses the pool presence, not
+        # `connected?` — ActiveRecord's connected? stays false until a
+        # connection is actually checked out, while pool.with_connection
+        # establishes lazily on first use.
+        def database_configured?
+          defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.connection_handler.retrieve_connection_pool(
+              ActiveRecord::Base.connection_specification_name
+            )
+        rescue StandardError
+          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
@@ -168,21 +194,39 @@ 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)
-
-          section.slice(*Configuration::DATABASE_CONFIG_KEYS).presence
+          yaml[env] || yaml["development"] || {}
         rescue Psych::Exception
           nil
         end
 
+        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") &&
+             config["database"] && !config["database"].start_with?("/", ":")
+            config["database"] = app_root.join(config["database"]).to_s
+          end
+          config.presence
+        end
+
         def default_system_prompt
           <<~PROMPT
             You are a Ruby software engineer.

metadata

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