ask-rails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '081f609a014a72157291794a40c580ed6fabb625c2db0c7511538acae540ea9b'
-  data.tar.gz: 1445552073a10f1fbae78f63d7220c894efbcb1cd6433f7aef8f977e4374b1e6
+  metadata.gz: e69600ee0def0363ad6aa80623bb2e6c160a5991bb8acf680a18d05eda8c9544
+  data.tar.gz: 558d9750d94d02b7de5ab05fcfe8edef68c33f28c6f5a7adf4e0e659856cc0d0
 SHA512:
-  metadata.gz: c0fcb6d2a6f53c8fa89dafd2ce2d6f3393c305a0df0cbfe67472798a9973032645e81ccec5517a855bba25e90572ac5c1100ba4d73b5e98e70ab329629e1ad99
-  data.tar.gz: 5227ec0290f2177f844922038439c99b7bfd8d0d35360b7256206825f220b0323d8d139117000169336f50242191b200f0896a79379d8769996aede9b2f12d36
+  metadata.gz: 40bc9bef781a02d9e020772846393ab0dcce0980b236739f532c87c06a7d7fd2fa24a13118d248a378236a2efc841cae130d61bcfc45230a02aac434626f743e
+  data.tar.gz: 3916e3a64be0401e75ff9a00a6febc537aa4d930db9696da1491f18aa0e99d89674aea97b778d1a0c2ca3fe48199e35ba49ff63a11e812d501ddb12590cd173c

data/lib/ask/rails/persistence.rb

@@ -4,39 +4,31 @@ module Ask
   module Rails
     class Persistence
       def initialize(model_class: nil)
-        @model_class = model_class || default_model_class
+        @model_class = model_class
       end
 
       def save(session_id, data)
-        record = @model_class.find_or_initialize_by(session_id: session_id)
+        record = model_class.find_or_initialize_by(session_id: session_id)
         record.update!(data: data)
       end
 
       def load(session_id)
-        record = @model_class.find_by(session_id: session_id)
+        record = model_class.find_by(session_id: session_id)
         record&.data
       end
 
       def delete(session_id)
-        @model_class.where(session_id: session_id).delete_all
+        model_class.where(session_id: session_id).delete_all
       end
 
       def list
-        @model_class.pluck(:session_id)
+        model_class.pluck(:session_id)
       end
 
       private
 
-      def default_model_class
-        # Lazy reference so the model class doesn't need to exist at load time
-        ask_session_model = Class.new(::ActiveRecord::Base) do
-          self.table_name = "ask_sessions"
-        end
-        # Store it as a constant so it's reusable
-        unless Object.const_defined?(:AskSession)
-          Object.const_set(:AskSession, ask_session_model)
-        end
-        AskSession
+      def model_class
+        @model_class || (raise "No model class configured. Use Persistence.new(model_class: MyModel)")
       end
     end
   end

data/lib/ask/rails/service_discovery.rb

@@ -14,10 +14,9 @@ module Ask
         service_gems.each do |name|
           begin
             require "#{name.tr("-", "/")}/context"
-            mod = name.camelize.constantize
-            contexts << mod if mod.const_defined?(:DESCRIPTION)
+            mod = name.split("-").map(&:capitalize).join.constantize
+            contexts << mod if mod.respond_to?(:const_defined?) && mod.const_defined?(:DESCRIPTION)
           rescue LoadError, NameError
-            # No context module for this gem
           end
         end
 
@@ -34,7 +33,8 @@ module Ask
         sections = ["## Available Services"]
 
         contexts.each do |mod|
-          sections << "### #{mod.name.demodulize}"
+          name = mod.respond_to?(:name) ? mod.name.to_s.split("::").last || "Unknown" : "Unknown"
+          sections << "### #{name}"
           sections << mod::DESCRIPTION if mod.const_defined?(:DESCRIPTION)
           sections << "Documentation: #{mod::DOCS_URL}" if mod.const_defined?(:DOCS_URL)
           sections << "Authentication: #{mod::AUTH_HOW}" if mod.const_defined?(:AUTH_HOW)

data/lib/ask/rails/tools/query_database.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Tools
+      class QueryDatabase < Ask::Rails::Tool
+        description "Run a read-only SQL query against the application database. " \
+                     "Returns columns and rows. Only SELECT queries are allowed in production."
+
+        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
+
+        WRITE_STATEMENTS = /\A\s*(INSERT|UPDATE|DELETE|DROP|TRUNCATE|ALTER|CREATE|GRANT|REVOKE)\b/i
+
+        def execute(sql:, limit: 50)
+          sql = sql.strip
+
+          if WRITE_STATEMENTS.match?(sql)
+            return Ask::Result.failure(
+              "Only SELECT queries are allowed. Write statements (#{sql.match(WRITE_STATEMENTS)[1]}) are rejected in all environments."
+            )
+          end
+
+          if Rails.env.production? && !sql.match?(/\A\s*SELECT\b/i)
+            return Ask::Result.failure(
+              "Only SELECT queries are allowed in the production environment."
+            )
+          end
+
+          pool = ActiveRecord::Base.connection_pool
+          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) }
+            {
+              columns: columns,
+              rows: rows,
+              count: rows.size,
+              truncated: result.rows.size > limit.to_i
+            }
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          Ask::Result.failure("SQL error: #{e.message}")
+        rescue ActiveRecord::ConnectionNotEstablished => e
+          Ask::Result.failure("Database not connected: #{e.message}. Verify the database is running and Rails is connected.")
+        end
+
+        private
+
+        def build_row(row, columns)
+          columns.each_with_index.each_with_object({}) do |(col, i), hash|
+            value = row[i]
+            hash[col] = sanitize_value(value)
+          end
+        end
+
+        def sanitize_value(value)
+          return "[BINARY DATA]" if binary_value?(value)
+          return value.iso8601 if value.respond_to?(:iso8601)
+          value
+        end
+
+        def binary_value?(value)
+          value.is_a?(String) && value.encoding == Encoding::ASCII_8BIT && value.bytesize > 0
+        rescue
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ask/rails/tools/read_log.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Tools
+      class ReadLog < Ask::Rails::Tool
+        description "Read application log files with filtering. Supports Rails default " \
+                     "logger and log rotation. Reads from the end of the file (most recent first)."
+
+        param :lines,  type: :integer, desc: "Number of recent lines (default 50, max 500)", required: false
+        param :level,  type: :string, desc: "Filter by level: ERROR, WARN, INFO, DEBUG", required: false
+        param :search, type: :string, desc: "Search term (plain text, case-insensitive)", required: false
+        param :file,   type: :string, desc: "Log file name (default: log/<env>.log)", required: false
+
+        MAX_LINES = 500
+        LEVEL_PATTERNS = {
+          "ERROR" => /\bERROR\b/,
+          "WARN"  => /\bWARN\b/,
+          "INFO"  => /\bINFO\b/,
+          "DEBUG" => /\bDEBUG\b/
+        }.freeze
+
+        def execute(lines: 50, level: nil, search: nil, file: nil)
+          lines = [lines.to_i, MAX_LINES].min
+          log_path = resolve_log_path(file)
+
+          unless log_path.exist?
+            return Ask::Result.failure(
+              "Log file not found: #{log_path}. The application may not have written any logs yet."
+            )
+          end
+
+          content = read_tail(log_path, MAX_LINES * 2)
+          return { lines: [], total_lines: 0, path: log_path.to_s } if content.empty?
+
+          raw_lines = content.lines
+
+          filtered = apply_filters(raw_lines, level: level, search: search)
+          recent = filtered.last(lines).map(&:chomp)
+
+          {
+            lines: recent,
+            total_lines: raw_lines.size,
+            matched_lines: filtered.size,
+            path: log_path.to_s,
+            filters_applied: { level: level, search: search }.compact
+          }
+        end
+
+        private
+
+        def resolve_log_path(custom_path)
+          return rails_root.join(custom_path) if custom_path
+          rails_root.join("log", "#{Rails.env}.log")
+        end
+
+        def read_tail(path, max_bytes)
+          return "" unless path.exist?
+
+          size = path.size
+          return path.read if size <= max_bytes
+
+          File.open(path, "rb") do |f|
+            f.seek(-max_bytes, IO::SEEK_END)
+            partial = f.read(max_bytes)
+            if (idx = partial.index("\n"))
+              partial[idx + 1..]
+            else
+              partial
+            end
+          end
+        end
+
+        def apply_filters(lines, level: nil, search: nil)
+          filtered = lines
+          filtered = filtered.select { |l| LEVEL_PATTERNS.fetch(level) { |_| // }.match?(l) } if level
+          filtered = filtered.select { |l| l.downcase.include?(search.downcase) } if search
+          filtered
+        end
+      end
+    end
+  end
+end

data/lib/ask/rails/tools/read_model.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Tools
+      class ReadModel < Ask::Rails::Tool
+        description "Inspect an ActiveRecord model — columns, associations, validations, " \
+                     "scopes, and indexes. Returns structured data the agent can act on."
+
+        param :name,   type: :string, desc: "Model class name (e.g. 'User', 'Blog::Post')", required: true
+        param :detail, type: :string, desc: "Which details: 'all' (default), 'columns', 'associations', 'validations'", required: false
+
+        def execute(name:, detail: "all")
+          klass = safe_constantize(name)
+          return Ask::Result.failure("Model '#{name}' not found or is not an ActiveRecord model.") unless klass
+
+          result = { name: klass.name, table_name: klass.table_name }
+
+          result[:primary_key] = klass.primary_key if klass.respond_to?(:primary_key)
+
+          if %w[all columns].include?(detail)
+            result[:columns] = klass.columns.map { |c|
+              entry = { name: c.name, type: c.type, null: c.null, default: c.default }
+              entry[:primary_key] = true if c.name == klass.primary_key
+              entry
+            }
+          end
+
+          if %w[all associations].include?(detail)
+            result[:associations] = klass.reflect_on_all_associations.group_by(&:macro).transform_values { |refs|
+              refs.map { |a|
+                entry = { name: a.name, class_name: a.class_name }
+                entry[:through] = a.options[:through] if a.options[:through]
+                entry[:source] = a.options[:source] if a.options[:source]
+                entry[:foreign_key] = a.foreign_key if a.respond_to?(:foreign_key)
+                entry
+              }
+            }
+          end
+
+          if %w[all validations].include?(detail)
+            result[:validators] = klass.validators.map { |v|
+              {
+                attribute: v.attributes.first&.to_s,
+                kind: v.kind,
+                options: v.options.reject { |k, _| k == :if }
+              }
+            }.reject { |v| v[:attribute].nil? }
+          end
+
+          result
+        end
+
+        private
+
+        def safe_constantize(name)
+          klass = name.safe_constantize
+          return nil unless klass
+          return nil unless klass < ActiveRecord::Base
+          klass
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ask/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module Rails
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/ask/rails.rb

@@ -74,3 +74,6 @@ require_relative "rails/tools/read_file"
 require_relative "rails/tools/run_command"
 require_relative "rails/tools/search_codebase"
 require_relative "rails/tools/read_routes"
+require_relative "rails/tools/query_database"
+require_relative "rails/tools/read_model"
+require_relative "rails/tools/read_log"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kaka Ruto
@@ -152,7 +152,10 @@ files:
 - lib/ask/rails/railtie.rb
 - lib/ask/rails/service_discovery.rb
 - lib/ask/rails/tool.rb
+- lib/ask/rails/tools/query_database.rb
 - lib/ask/rails/tools/read_file.rb
+- lib/ask/rails/tools/read_log.rb
+- lib/ask/rails/tools/read_model.rb
 - lib/ask/rails/tools/read_routes.rb
 - lib/ask/rails/tools/run_command.rb
 - lib/ask/rails/tools/search_codebase.rb