ask-ruby-harness 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 411e139b4a5cfe5e017a748753c36a1f811a45f719e2245c7789267d4fe9f476
-  data.tar.gz: bd78de0520de347c8ffb675c7c704187c98fc7971b3b4a30770c227479adf7f3
+  metadata.gz: b57d0a2408bc2432ed17401048b318263ac9e11709d73cd4eba7b2b47d2e9997
+  data.tar.gz: 910fa5fdc3a9a8da190fe05bd5326698043f4615853f3908648c05df55316d51
 SHA512:
-  metadata.gz: 4010a7f88a99c289dc68a1bbb40e7b8b829ac794b2a9daf609558128dad5b809f1a6900fae0d8d4c46d795ab69aa5802aa4cfde361256601c913d893f2551000
-  data.tar.gz: 6c0362992da2df7e54e0191fbc494c35c90641d538c9f2f7ea63e58b8a33a5d4a9248f32ee58def32d5db09547c83887dd598f7dbe524fc98b19a29c04a6f4bb
+  metadata.gz: 184e86499d3e1eede9de25e6ee241dc01dfaa2f504ae5de616c7e64cf845b83f12ee2e7681e55b7310078e72435db14f7a806e2526dcced4d70c298cecbb7518
+  data.tar.gz: 49e9aae381d3d619787f1420f103b1d09732de6370cb43dc367b5d2d82e8cb6f1043394e449812f53abbe13faff70aa3dd1761a020f8d556f41077e477a2942a

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/tools/run_tests.rb

@@ -30,6 +30,14 @@ module Ask
             files = files.map { |f| rel_to_run_root(f, run_root) }
             runner = detect_runner(run_root)
 
+            # rake test only takes files (TEST env); expand directory args to
+            # their *_test.rb files. Rails and rspec expand dirs natively.
+            if runner == :minitest
+              expanded = expand_minitest_directories(files, run_root)
+              return expanded unless expanded.is_a?(Array)
+              files = expanded
+            end
+
             failed_tests = failed_only ? load_failed_tests(run_root) : nil
             if failed_only && failed_tests.empty?
               return Ask::Result.failure("No failed tests from the previous run to rerun.")
@@ -40,6 +48,10 @@ module Ask
             json_path = artifact_dir.join("last-test.json")
             status_path = artifact_dir.join("last-failures.json")
 
+            # A child that produces no JSON must not be masked by a previous
+            # run's stale file — parse_results only looks at this path.
+            json_path.delete if json_path.exist?
+
             command, env = build_command(runner, files, name, failed_tests, json_path)
             outcome = run(command, env, log_path, timeout, run_root)
 
@@ -101,6 +113,25 @@ module Ask
             Pathname.new(File.expand_path(file, app_root)).relative_path_from(run_root).to_s
           end
 
+          # rake_test_loader requires each arg as a file — a directory arg
+          # explodes ("cannot load such file -- .../test"). Replace directory
+          # args with the *_test.rb files under them (relative to run_root),
+          # mirroring the standard Rake::TestTask pattern.
+          def expand_minitest_directories(files, run_root)
+            files.flat_map do |f|
+              dir = File.join(run_root.to_s, f)
+              next f unless File.directory?(dir)
+
+              matches = Dir.glob(File.join(dir, "**", "*_test.rb"))
+                          .map { |m| Pathname.new(m).relative_path_from(run_root).to_s }
+                          .uniq
+              if matches.empty?
+                return Ask::Result.failure("No *_test.rb files found under '#{f}'.")
+              end
+              matches
+            end.uniq
+          end
+
           def build_command(runner, files, name, failed_tests, json_path)
             case runner
             when :rspec
@@ -125,11 +156,25 @@ module Ask
               # arrives via RUBYOPT like everywhere else.
               args = ["bundle", "exec", "rake", "test"]
               env = injection_env(json_path)
-              env["TEST"] = files.first if files.size == 1
+              # Rake::TestTask reads TEST/TESTOPTS from the environment, so
+              # the child inherits whatever the parent run carried (nested
+              # runs!) unless it's overwritten or cleared here — a stray TEST
+              # pointing at the outer project's files would abort the inner
+              # run before any test loads.
+              env["TEST"] = files.any? ? files.join(",") : nil
               testopts = []
               testopts << "--name=#{name}" if name
               testopts << "--name=#{name_pattern(failed_tests)}" if failed_tests
-              env["TESTOPTS"] = testopts.join(" ") unless testopts.empty?
+              if testopts.empty?
+                env["TESTOPTS"] = nil
+              else
+                # rake's test task runs ruby through the shell, so unquoted
+                # TESTOPTS with `|` (failed_only alternations) or spaces gets
+                # split into bogus commands. Quote each option so it survives
+                # as one ARGV entry in rake_test_loader.
+                env["TESTOPTS"] = testopts.map { |o| "\"#{o}\"" }.join(" ")
+              end
+              %w[TESTOPT TEST_OPTS TEST_OPT].each { |k| env[k] = nil }
               [args, env]
             end
           end

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

@@ -3,7 +3,7 @@
 module Ask
   module Ruby
     module Harness
-      VERSION = "0.2.1"
+      VERSION = "0.3.1"
     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.1
 platform: ruby
 authors:
 - Kaka Ruto