ask-rails 0.2.5 → 0.6.0

data/lib/ask/rails/persistence.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    class Persistence
-      def initialize(model_class: nil)
-        @model_class = model_class
-      end
-
-      def save(session_id, data)
-        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&.data
-      end
-
-      def delete(session_id)
-        model_class.where(session_id: session_id).delete_all
-      end
-
-      def list
-        model_class.pluck(:session_id)
-      end
-
-      private
-
-      def model_class
-        @model_class || (raise "No model class configured. Use Persistence.new(model_class: MyModel)")
-      end
-    end
-  end
-end

data/lib/ask/rails/service_discovery.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module ServiceDiscovery
-      SERVICE_GEMS_PATTERN = /\Aask-(?!tools|tools-shell|agent|rails|core|auth|schema|llm)/
-
-      module_function
-
-      def discover!
-        service_gems = Gem.loaded_specs.keys.select { |name| name.match?(SERVICE_GEMS_PATTERN) }
-        contexts = []
-
-        service_gems.each do |name|
-          begin
-            require "#{name.tr("-", "/")}/context"
-            mod = name.split("-").map(&:capitalize).join.constantize
-            contexts << mod if mod.respond_to?(:const_defined?) && mod.const_defined?(:DESCRIPTION)
-          rescue LoadError, NameError
-          end
-        end
-
-        unless contexts.empty?
-          prompt = build_system_prompt(contexts)
-          existing = Ask::Rails.configuration.system_prompt
-          Ask::Rails.configuration.system_prompt = [existing, prompt].compact.join("\n\n")
-        end
-
-        contexts
-      end
-
-      def build_system_prompt(contexts)
-        sections = ["## Available Services"]
-
-        contexts.each do |mod|
-          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)
-          sections << ""
-        end
-
-        sections.join("\n")
-      end
-    end
-  end
-end

data/lib/ask/rails/tool.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    class Tool < Ask::Tool
-      def rails_root
-        ::Rails.root
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# 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_file.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class ReadFile < Ask::Rails::Tool
-        description "Read a file from the Rails app. Paths are relative to Rails.root."
-
-        param :path, type: :string, desc: "Relative path from Rails.root", required: true
-
-        def execute(path:)
-          full_path = rails_root.join(path)
-          return Ask::Result.error(message: "File not found: #{path}") unless full_path.exist?
-
-          content = full_path.read
-          Ask::Result.success(
-            data: { path: path, content: content, size: content.length },
-            metadata: { path: path, size: content.length }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-# 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/i,
-          "WARN"  => /\bWARN\b/i,
-          "INFO"  => /\bINFO\b/i,
-          "DEBUG" => /\bDEBUG\b/i
-        }.freeze
-
-        def execute(lines: 50, level: nil, search: nil, file: nil)
-          max_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
-
-          raw_lines = read_all_log_files(log_path)
-          return { lines: [], total_lines: 0, path: log_path.to_s } if raw_lines.empty?
-
-          filtered = apply_filters(raw_lines, level: level, search: search)
-          recent = filtered.last(max_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
-
-        # Read from rotated archives too: log/production.log, .1, .2.gz, etc.
-        def read_all_log_files(log_path)
-          all_content = +""
-          rotated_files(log_path).each do |path|
-            content = read_file_content(path)
-            all_content.prepend(content) if content
-          end
-          all_content.lines
-        end
-
-        def rotated_files(log_path)
-          dir = log_path.dirname
-          base = log_path.basename.to_s
-          # Primary file, then rotated files in reverse order (oldest first, then primary last)
-          pattern = File.join(dir, "#{base}.*")
-          rotations = Dir[pattern].sort_by { |f| extract_rotation_number(f) }
-          # Primary file is read last (most recent)
-          rotations + [log_path.to_s]
-        end
-
-        def extract_rotation_number(path)
-          File.basename(path).sub(/.*\.(\d+)(\.gz)?$/, '\1').to_i
-        rescue
-          0
-        end
-
-        def read_file_content(path)
-          if path.to_s.end_with?(".gz")
-            Zlib::GzipReader.open(path.to_s) { |gz| gz.read }
-          else
-            File.read(path.to_s)
-          end
-        rescue => e
-          warn "[ReadLog] Could not read #{path}: #{e.message}"
-          nil
-        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

@@ -1,73 +0,0 @@
-# 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', 'scopes'", 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 scopes].include?(detail) && klass.respond_to?(:all)
-            result[:scopes] = klass.methods(false)
-              .reject { |m| m.to_s.end_with?("=", "!", "?") || %i[new allocate inspect to_s].include?(m) }
-              .map(&:to_s).sort
-          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/tools/read_routes.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class ReadRoutes < Ask::Rails::Tool
-        description "Read the Rails routes from config/routes.rb"
-        def execute
-          routes_file = rails_root.join("config", "routes.rb")
-          return Ask::Result.error(message: "No routes file found") unless routes_file.exist?
-
-          content = routes_file.read
-          Ask::Result.success(
-            data: { content: content },
-            metadata: { size: content.length }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class RunCommand < Ask::Rails::Tool
-        description "Run a shell command in the Rails app root directory."
-        param :command, type: :string, desc: "Shell command to run", required: true
-
-        def execute(command:)
-          output = `cd #{rails_root} && #{command} 2>&1`
-          Ask::Result.success(
-            data: { output: output, exit_status: $?.exitstatus },
-            metadata: { exit_status: $?.exitstatus }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Ask
-  module Rails
-    module Tools
-      class SearchCodebase < Ask::Rails::Tool
-        description "Search the Rails codebase with grep."
-        param :pattern, type: :string, desc: "Search pattern", required: true
-        param :path, type: :string, desc: "Subdirectory to search (optional)"
-
-        def execute(pattern:, path: nil)
-          search_path = path ? rails_root.join(path) : rails_root
-          results = `cd #{rails_root} && grep -rn '#{pattern}' #{search_path} 2>&1 | head -50`
-          Ask::Result.success(
-            data: { results: results, count: results.lines.count },
-            metadata: { pattern: pattern, count: results.lines.count }
-          )
-        end
-      end
-    end
-  end
-end

data/lib/ask/skills/rails.db_debug/SKILL.md

@@ -1,118 +0,0 @@
----
-name: rails.db_debug
-description: Step-by-step methodology for debugging database performance issues in Rails
----
-
-Use this skill when investigating slow queries, N+1 problems, missing indexes, or
-general database performance issues in a Rails application.
-
-## Step 1: Identify the Slow Queries
-
-Use `ReadLog.new.call(lines: 200, search: "SELECT")` to find recent database
-queries in the application log. Look for:
-
-- Queries taking > 100ms (look for "duration:" or "↳" markers in Rails logs)
-- Repetitive queries with the same structure (potential N+1)
-- Queries running in loops (same query, different IDs)
-
-If you need more detail, narrow the search: `ReadLog.new.call(lines: 500, level: "WARN")`.
-
-## Step 2: Understand the Schema
-
-For each model involved in the slow queries, inspect it:
-
-```ruby
-ReadModel.new.call(name: "User")
-ReadModel.new.call(name: "Post")
-```
-
-Focus on:
-- **Columns** — are there columns that look like foreign keys without indexes?
-- **Associations** — what associations exist and what `class_name` do they use?
-- **Validators** — any database-level constraints that could be missing?
-
-Run `ReadModel.new.call(name: "User", detail: "columns")` if you only need columns.
-
-## Step 3: Check for Missing Indexes
-
-Query the database for actual indexes:
-
-```ruby
-QueryDatabase.new.call(
-  sql: "SELECT tablename, indexname, indexdef FROM pg_indexes WHERE schemaname = 'public' ORDER BY tablename, indexname",
-  limit: 200
-)
-```
-
-Look for:
-- Foreign key columns that lack indexes (e.g. `user_id` without index)
-- Columns used in `WHERE` clauses without indexes
-- Composite indexes that could cover multiple query patterns
-
-If an index is missing, check if adding one would help:
-```ruby
-QueryDatabase.new.call(
-  sql: "EXPLAIN ANALYZE SELECT * FROM posts WHERE user_id = 1",
-  limit: 10
-)
-```
-
-## Step 4: Detect N+1 Queries
-
-N+1 manifests as the same query repeated with different IDs:
-
-```ruby
-# Search for repetitive query patterns
-ReadLog.new.call(lines: 500, search: "WHERE.*IN")
-```
-
-Common N+1 patterns:
-- Loading `Post.all` then accessing `post.comments` individually
-- Loading `User.all` then accessing `user.profile` individually
-- Serializing associations in views without eager loading
-
-Fix with `.includes(:association)`, `.eager_load(:association)`, or
-`.preload(:association)`.
-
-## Step 5: Profile Slow Queries with EXPLAIN
-
-For any identified slow query, get the execution plan:
-
-```ruby
-QueryDatabase.new.call(
-  sql: "EXPLAIN (ANALYZE, BUFFERS) SELECT posts.* FROM posts WHERE posts.user_id = 1 ORDER BY posts.created_at DESC LIMIT 20",
-  limit: 10
-)
-```
-
-What to look for in explain output:
-- **Sequential scans** (`Seq Scan`) — missing index
-- **Sort operations** — missing index on sort column
-- **Nested loop joins** with high row counts — missing composite index
-- **Bitmap heap scans** with high costs — index may be suboptimal
-
-If `ANALYZE` takes too long, use `EXPLAIN (BUFFERS)` without `ANALYZE` for cost estimates.
-
-## Step 6: Check Bulk Loading and Batch Operations
-
-If the issue involves importing or updating many records:
-
-```ruby
-QueryDatabase.new.call(
-  sql: "SELECT schemaname, tablename, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch FROM pg_stat_user_tables ORDER BY seq_scan DESC",
-  limit: 20
-)
-```
-
-High `seq_scan` counts compared to `idx_scan` indicate tables where indexes
-are missing and sequential scans are happening frequently.
-
-## Failure Mode Guide
-
-| Symptom | Likely Cause | Action |
-|---------|-------------|--------|
-| Query takes >1s | Missing index on WHERE column | Check pg_indexes, add index |
-| Same query 50x in log | N+1 in controller/view | Add `.includes()` |
-| Query slow AFTER adding index | Wrong index type or order | Verify index column order matches query |
-| `EXPLAIN ANALYZE` hanging | Table lock or very large table | Use `EXPLAIN (BUFFERS)` without ANALYZE |
-| Missing `pg_indexes` output | Not Postgres | Use `SHOW INDEX FROM <table>` for MySQL |