ask-rails-harness 0.1.0

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class ReadLog < Ask::Rails::Harness::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
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class ReadModel < Ask::Rails::Harness::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
+end

data/lib/ask/rails/harness/tools/read_routes.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class ReadRoutes < Ask::Rails::Harness::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
+            { content: content, size: content.length }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ask/rails/harness/tools/route_inspector.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class RouteInspector < Ask::Rails::Harness::Tool
+          description "Return the parsed Rails route table — every route with its HTTP verb, path, " \
+                       "controller, action, and name. Returns structured data the agent can filter " \
+                       "and reason about, unlike reading the raw routes.rb file."
+
+          param :controller, type: :string, desc: "Filter by controller name (e.g. 'users', 'api/v1/posts')", required: false
+          param :pattern, type: :string, desc: "Filter by path pattern (e.g. 'users', 'admin')", required: false
+          param :verbose, type: :boolean, desc: "Include internal route details (default false)", required: false
+
+          def execute(controller: nil, pattern: nil, verbose: false)
+            return { routes: [], count: 0 } unless defined?(::Rails) && ::Rails.application&.routes
+
+            all_routes = ::Rails.application.routes.routes.map do |route|
+              entry = {
+                verb: verb_for(route),
+                path: route.path.spec.to_s.delete_suffix("(.:format)"),
+                controller: route.defaults[:controller]&.to_s,
+                action: route.defaults[:action]&.to_s,
+                name: route.name&.to_s
+              }
+
+              if verbose
+                entry[:requirements] = route.required_parts.presence
+                entry[:defaults] = route.defaults.except(:controller, :action).presence
+                entry[:constraints] = route.constraints.except(:request_method).presence if route.constraints.any?
+              end
+
+              entry
+            end
+
+            # Remove internal/engine routes unless verbose
+            unless verbose
+              all_routes.reject! { |r| r[:controller].nil? || r[:controller].start_with?("rails/") }
+            end
+
+            # Apply filters
+            all_routes.select! { |r| r[:controller] == controller } if controller
+            all_routes.select! { |r| r[:path].include?(pattern) } if pattern
+
+            {
+              routes: all_routes,
+              count: all_routes.size
+            }
+          end
+
+          private
+
+          def verb_for(route)
+            if route.verb.is_a?(String)
+              route.verb
+            elsif route.verb.respond_to?(:call)
+              # Rails stores verb as a regexp — extract the source
+              source = route.verb.source
+              source.gsub(/[$^\\]/, "").split("|")
+            else
+              "ANY"
+            end
+          rescue
+            "ANY"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class RunCommand < Ask::Rails::Harness::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:)
+            check_result = check_command_allowed(command)
+            return check_result if check_result
+
+            output = `cd #{rails_root} && #{command} 2>&1`
+            Ask::Result.ok(
+              data: { output: output, exit_status: $?.exitstatus },
+              metadata: { exit_status: $?.exitstatus }
+            )
+          end
+
+          private
+
+          def check_command_allowed(command)
+            config = Ask::Rails::Harness.configuration
+
+            # Use per-environment rules if configured, fall back to global
+            denied = config.effective_denied_commands
+            allowed = config.effective_allowed_commands
+
+            # 1. Check denied commands first (takes precedence)
+            if denied
+              denied.each do |pattern|
+                if command.match?(pattern)
+                  return Ask::Result.error(
+                    message: "Command blocked by deny rule: #{pattern.inspect}"
+                  )
+                end
+              end
+            end
+
+            # 2. Check allowed commands (if configured)
+            if allowed
+              matches = allowed.any? { |pattern| command.match?(pattern) }
+              unless matches
+                allowed_desc = allowed.map(&:inspect).join(", ")
+                return Ask::Result.error(
+                  message: "Command blocked: does not match any allowed pattern (#{allowed_desc})"
+                )
+              end
+            end
+
+            # 3. No restrictions configured — allow
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ask/rails/harness/tools/schema_graph.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class SchemaGraph < Ask::Rails::Harness::Tool
+          description "Return the full application schema graph — all models, tables, columns with types, " \
+                       "associations (belongs_to, has_many, has_one, HABTM, through), validations, indexes, " \
+                       "and polymorphic relationships. One call gives the agent a complete mental model " \
+                       "of the application's data layer."
+
+          param :detail, type: :string, desc: "Detail level: 'all' (default), 'models', 'associations', 'tables'", required: false
+
+          TABLE_EXCLUSIONS = %w[schema_migrations ar_internal_metadata].freeze
+
+          def execute(detail: "all")
+            models = discover_ar_models
+
+            result = {
+              summary: {
+                model_count: models.size,
+                table_count: models.map { |m| m.table_name }.uniq.size,
+                association_count: models.sum { |m| m.reflect_on_all_associations.size }
+              },
+              models: %w[all models].include?(detail) ? build_model_details(models, detail) : nil,
+              associations: %w[all associations].include?(detail) ? build_association_graph(models) : nil,
+              tables: %w[all tables].include?(detail) ? build_table_details(detail) : nil
+            }
+
+            result
+          end
+
+          private
+
+          def discover_ar_models
+            if defined?(::Rails::Application) && ::Rails.application
+              ::Rails.application.eager_load! rescue nil
+            end
+            ActiveRecord::Base.descendants.reject do |klass|
+              klass.abstract_class? ||
+              klass.name.nil? ||
+              TABLE_EXCLUSIONS.include?(klass.table_name) ||
+              klass.name.start_with?("ActiveRecord::", "ActiveStorage::", "ActionText::")
+            end.sort_by(&:name)
+          rescue StandardError
+            []
+          end
+
+          def build_model_details(models, detail)
+            models.filter_map do |klass|
+              name = klass.name rescue nil
+              next nil unless name
+
+              entry = {
+                name: name,
+                table_name: klass.table_name,
+                primary_key: safe_primary_key(klass)
+              }
+
+              if klass.respond_to?(:columns)
+                entry[:columns] = safe_columns(klass)
+              end
+
+              if klass.respond_to?(:reflect_on_all_associations)
+                entry[:associations] = klass.reflect_on_all_associations.group_by(&:macro).transform_values { |refs|
+                  refs.map { |a|
+                    assoc = { name: a.name, class_name: a.class_name }
+                    assoc[:through] = a.options[:through] if a.options[:through]
+                    assoc[:source] = a.options[:source] if a.options[:source]
+                    assoc[:foreign_key] = a.foreign_key
+                    assoc[:polymorphic] = true if a.polymorphic?
+                    assoc[:as] = a.options[:as] if a.options[:as]
+                    assoc[:dependent] = a.options[:dependent] if a.options[:dependent]
+                    assoc
+                  }
+                }
+              end
+
+              if klass.respond_to?(:validators)
+                entry[: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
+
+              entry
+            end
+          end
+
+          def build_association_graph(models)
+            edges = []
+
+            models.each do |klass|
+              klass.reflect_on_all_associations.each do |a|
+                next if a.macro == :has_many && a.options[:through]  # Skip through associations (derived)
+
+                target_model = find_model_for_association(models, a)
+                next unless target_model
+
+                edges << {
+                  from: klass.name,
+                  to: target_model.name,
+                  type: a.macro,
+                  via: a.name,
+                  foreign_key: a.foreign_key,
+                  polymorphic: a.polymorphic? || false
+                }
+              end
+            end
+
+            edges
+          end
+
+          def find_model_for_association(models, association)
+            class_name = association.class_name
+            # Try exact match first, then match by class name suffix (handles namespace issues)
+            models.find { |m| m.name == class_name } ||
+              models.find { |m| m.name.end_with?("::#{class_name}") } ||
+              models.find { |m| class_name.end_with?("::#{m.name}") }
+          end
+
+          def build_table_details(detail)
+            models = discover_ar_models
+            tables = {}
+
+            models.each do |klass|
+              table = klass.table_name
+              next if TABLE_EXCLUSIONS.include?(table)
+
+              tables[table] = {
+                model: klass.name,
+                columns: safe_columns(klass),
+                indexes: fetch_indexes_for(table)
+              }
+            end
+
+            tables
+          end
+
+          def safe_primary_key(klass)
+            klass.primary_key
+          rescue StandardError
+            nil
+          end
+
+          def safe_columns(klass)
+            klass.columns.map { |c|
+              col = { name: c.name, type: c.type, null: c.null }
+              col[:default] = c.default unless c.default.nil?
+              col[:primary_key] = true if c.name == klass.primary_key
+              col
+            }
+          rescue StandardError
+            []
+          end
+
+          def fetch_indexes_for(table_name)
+            ActiveRecord::Base.connection.indexes(table_name).map do |idx|
+              {
+                name: idx.name,
+                columns: idx.columns,
+                unique: idx.unique
+              }
+            end
+          rescue StandardError
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      module Tools
+        class SearchCodebase < Ask::Rails::Harness::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)", required: false
+
+          def execute(pattern:, path: nil)
+            search_path = (path ? rails_root.join(path) : rails_root).to_s
+            escaped_pattern = pattern.gsub("'", "'\\\\''")
+            escaped_path = search_path.gsub("'", "'\\\\''")
+            results = `cd #{rails_root} && grep -rn '#{escaped_pattern}' #{escaped_path} 2>&1 | head -50`
+            { results: results.lines.map(&:chomp), count: results.lines.count }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ask
+  module Rails
+    module Harness
+      VERSION = "0.1.0"
+    end
+  end
+end