rails_console_pro 0.1.2 → 0.1.3

data/QUICK_START.md

@@ -59,6 +59,13 @@ export schema(User) user_schema.json
 ```
 [Learn more →](docs/EXPORT.md)
 
+### Snippet Library
+```ruby
+snippets(:add, "User.where(active: true).count", description: "Active users", tags: %w[users metrics])
+snippets(:list)
+```
+[Learn more →](docs/SNIPPETS.md)
+
 ### Beautiful Formatting
 ```ruby
 User.first  # Automatically formatted with colors
@@ -103,6 +110,7 @@ rails generate rails_console_pro:install
 - [Association Navigation](docs/ASSOCIATION_NAVIGATION.md)
 - [Object Diffing](docs/OBJECT_DIFFING.md)
 - [Export](docs/EXPORT.md)
+- [Snippets](docs/SNIPPETS.md)
 - [Formatting](docs/FORMATTING.md)
 
 ## Need Help?

data/README.md

@@ -14,9 +14,12 @@ Rails Console Pro transforms your Rails console into a powerful debugging enviro
 - 🔍 **SQL Explain** - Analyze query execution plans with performance recommendations
 - 🧭 **Association Navigator** - Interactive navigation through model associations
 - 📈 **Model Statistics** - Record counts, growth rates, table sizes, and index usage
+- 🔬 **Adaptive Profiling** - Profile blocks or relations with query, cache, and performance metrics
+- 🧵 **ActiveJob Insights** - Inspect and manage queues across adapters (Sidekiq, SolidQueue, Test, Async) with filters and inline actions
 - 🔄 **Object Diffing** - Compare ActiveRecord objects and highlight differences
 - 💾 **Export Capabilities** - Export to JSON, YAML, and HTML formats
 - 📄 **Smart Pagination** - Automatic pagination for large collections
+- 📝 **Snippet Library** - Capture, search, and reuse console snippets across sessions
 
 ## 🚀 Installation
 
@@ -62,6 +65,15 @@ diff user1, user2
 
 # Export
 export schema(User) user_schema.json
+
+# Profiling
+profile('Load users') { User.active.includes(:posts).limit(10).to_a }
+
+# Queue insights
+jobs(limit: 10, queue: 'mailers')
+jobs status=retry class=ReminderJob
+jobs retry=abcdef123456
+jobs details=abcdef123456
 ```
 
 See [QUICK_START.md](QUICK_START.md) for more examples and detailed documentation for each feature.
@@ -78,6 +90,7 @@ RailsConsolePro.configure do |config|
   config.schema_command_enabled = true
   config.explain_command_enabled = true
   config.stats_command_enabled = true
+  config.queue_command_enabled = true
   
   # Color scheme
   config.color_scheme = :dark  # or :light
@@ -107,7 +120,10 @@ end
 - [Association Navigation](docs/ASSOCIATION_NAVIGATION.md) - Navigate model associations
 - [Object Diffing](docs/OBJECT_DIFFING.md) - Compare objects
 - [Export](docs/EXPORT.md) - Export to JSON, YAML, HTML
+- [Snippets](docs/SNIPPETS.md) - Build a reusable console snippet library
 - [Formatting](docs/FORMATTING.md) - Beautiful console output
+- [Adaptive Profiling](docs/PROFILING.md) - Measure queries, cache hits, and potential N+1 issues
+- [Queue Insights](docs/QUEUE_INSIGHTS.md) - Inspect jobs across ActiveJob adapters
 
 ## 🤝 Contributing
 

data/docs/FORMATTING.md

@@ -84,3 +84,8 @@ end
 - **Clean Layout**: Well-organized, readable output
 - **Dark/Light Themes**: Choose your preferred color scheme
 
+## Screenshots
+
+<img width="1117" height="551" alt="Screenshot 2025-11-07 at 11 42 52 AM" src="https://github.com/user-attachments/assets/2e77e0d5-8fa1-4249-8b0f-f8d16e829d99" />
+
+

data/docs/MODEL_STATISTICS.md

@@ -70,3 +70,7 @@ export stats(User) user_stats.json
 - **Index Usage**: Which indexes are used frequently
 - **Column Statistics**: Unique values, distributions, ranges (for smaller tables)
 
+## Screenshots
+
+<img width="1119" height="714" alt="Screenshot 2025-11-07 at 11 44 01 AM" src="https://github.com/user-attachments/assets/a175cb8c-1bea-4819-a80b-3f0bbb0d1a75" />
+

data/docs/OBJECT_DIFFING.md

@@ -85,3 +85,9 @@ diff(user1, user2).to_json
 - **Multiple Object Types**: Works with ActiveRecord, Hash, and more
 - **Export Support**: Export diff results to JSON/YAML/HTML
 
+## Screenshots
+
+<img width="1057" height="650" alt="Screenshot 2025-11-07 at 11 27 23 AM" src="https://github.com/user-attachments/assets/ca9fce82-8ed8-4506-907b-75e07735ec66" />
+
+
+

data/docs/PROFILING.md

@@ -0,0 +1,91 @@
+# Adaptive Profiling
+
+Rails Console Pro includes an adaptive profiler that wraps any block, callable, or ActiveRecord relation and reports real-time performance metrics without leaving the console.
+
+## Why Use It?
+
+- Understand how long a console experiment takes end-to-end
+- See how much time is spent inside SQL queries
+- Detect cache hits/misses and duplicated queries (potential N+1s)
+- Keep a sample of executed SQL statements with bind values
+- Capture errors while still getting timing information
+
+## Basic Usage
+
+```ruby
+# Profile a block
+profile { User.active.limit(25).to_a }
+
+# Add a label for the session
+profile('Load active users') { User.active.includes(:posts).limit(25).to_a }
+
+# Profile a relation (loads it automatically)
+relation = User.includes(:posts).limit(10)
+profile relation
+
+# Profile any callable object
+profile -> { HeavyService.call(user) }
+```
+
+`profile` returns a `RailsConsolePro::ProfileResult` instance, so you can further inspect or export the collected metrics.
+
+## Sample Output
+
+```
+🧪 PROFILE: Load active users
+⏱ Execution Summary:
+  Total time        35.42 ms
+  SQL time          28.12 ms
+    (79.36% of total time spent in SQL)
+
+🗂 Query Breakdown:
+  Total queries     4
+  Read queries      4
+  Write queries     0
+  Cached queries    1
+
+🐢 Slow Queries (100.0ms+):
+  1. 120.44 ms SELECT "users".* FROM ...
+```
+
+The printer also highlights cache activity, sample queries, potential N+1 issues, and any error raised during execution.
+
+## Configuration
+
+Tune profiling behaviour via the initializer:
+
+```ruby
+RailsConsolePro.configure do |config|
+  # Enable/disable the profile command
+  config.profile_command_enabled = true
+
+  # Flag queries above this threshold (milliseconds)
+  config.profile_slow_query_threshold = 120.0
+
+  # Minimum occurrences before a query is treated as a possible N+1
+  config.profile_duplicate_query_threshold = 3
+
+  # Number of query samples to keep in memory for reporting
+  config.profile_max_saved_queries = 10
+end
+```
+
+## Exporting
+
+Profile results can be exported like any other value object:
+
+```ruby
+result = profile { User.active.limit(10).to_a }
+
+result.to_json
+result.to_yaml
+result.export_to_file('profile.html', format: :html)
+```
+
+## Tips
+
+- Combine profiling with Rails scopes to analyse real data paths
+- Lower `profile_slow_query_threshold` when testing on local databases
+- Use labels to differentiate multiple runs in the same console session
+- Errors are captured and displayed; you still get timings even when the block fails
+

data/docs/QUEUE_INSIGHTS.md

@@ -0,0 +1,82 @@
+# Queue Insights
+
+Rails Console Pro introduces a `jobs` command that surfaces ActiveJob activity without leaving the console. It aggregates state from the underlying queue adapter so you can quickly review what is enqueued, retrying, or currently executing.
+
+## Supported Adapters
+
+The command automatically detects the adapter backing `ActiveJob::Base.queue_adapter` and falls back gracefully when a feature is unavailable.
+
+| Adapter | Enqueued | Retries | Recent Executions | Notes |
+| ------- | -------- | ------- | ----------------- | ----- |
+| Sidekiq | ✅ | ✅ (`RetrySet`) | ✅ (`Workers`) | Requires Redis connection |
+| SolidQueue | ✅ (`ready`) | ✅ (`retryable`/`failed`) | ✅ (`Execution`/`CompletedExecution`) | Works with default SolidQueue tables |
+| Test / Inline / Async | ✅ (`enqueued_jobs`) | ❌ | ✅ (`performed_jobs` when available) | Primarily for development/test |
+
+> **Tip:** When an adapter does not expose a given dataset, the section is omitted and a warning is printed where appropriate.
+>
+> When Sidekiq or SolidQueue are loaded but ActiveJob is still using the default async adapter, Rails Console Pro automatically falls back to the native queue APIs so you still see those jobs. For Sidekiq, ensure `sidekiq/api` is required in the console (most Rails apps do this automatically). Inline actions (`retry=`, `delete=`, `details=`) currently target Sidekiq queues.
+
+## Usage
+
+```ruby
+# Everything (auto-detected adapter)
+jobs
+
+# Limit the number of entries
+jobs(limit: 10)
+
+# Focus on a specific queue (if the adapter supports it)
+jobs(queue: "mailers")
+
+# Combine options
+jobs(limit: 5, queue: "critical")
+
+# Filter by status or job class
+jobs status=retry
+jobs status=enqueued,retry class=ReminderJob
+
+# Inline queue actions
+jobs retry=abcdef123456
+jobs delete=abcdef123456
+jobs details=abcdef123456
+```
+
+In Pry you can use CLI-style arguments:
+
+```
+jobs limit=5 queue=critical
+jobs 10 mailers
+jobs status=retry class=ReminderJob
+jobs --retry-only
+jobs retry=abcdef123456
+jobs delete=abcdef123456
+jobs details=abcdef123456
+```
+
+## Output
+
+The printer renders three sections when data is available:
+
+1. **📬 Enqueued Jobs** – Most recent enqueued jobs with timestamps and arguments.
+2. **🔁 Retry Set** – Jobs scheduled for retry or marked as failed.
+3. **⚙️ Recent Executions** – Currently running jobs (Sidekiq) or recently performed jobs (other adapters).
+
+Adapter statistics (e.g., processed, failed) appear under **ℹ️ Adapter Stats** when provided by the backend.
+
+## Configuration
+
+The feature is enabled by default. Toggle it in your initializer if needed:
+
+```ruby
+RailsConsolePro.configure do |config|
+  config.queue_command_enabled = true # or false to disable
+end
+```
+
+## Troubleshooting
+
+- **Missing data:** Ensure the backing queue system is reachable (e.g., Redis for Sidekiq).
+- **Adapter-specific warnings:** These indicate the adapter API is unavailable or the command lacks sufficient access. The command continues with available sections.
+- **Custom adapters:** The command falls back to ActiveJob's generic `enqueued_jobs` / `performed_jobs` APIs when present.
+
+

data/docs/SCHEMA_INSPECTION.md

@@ -57,4 +57,9 @@ schema(User).to_json
 # Export to file
 export schema(User) user_schema.json
 ```
+## Screenshots
 
+
+<img width="1114" height="722" alt="Screenshot 2025-11-07 at 11 27 52 AM" src="https://github.com/user-attachments/assets/ab93a9b9-4b59-4032-b15e-06fe1ef069c6" />
+
+<img width="1107" height="498" alt="Screenshot 2025-11-07 at 11 28 01 AM" src="https://github.com/user-attachments/assets/27f9e85a-8e5d-48f6-9a75-b69fde3dbb5c" />

data/docs/SNIPPETS.md

@@ -0,0 +1,71 @@
+# Snippet Library
+
+Rails Console Pro ships with a developer-friendly snippet library that helps you capture, search, and reuse the console commands you rely on every day.
+
+## Overview
+
+- Store frequently used console expressions with a short description and optional tags
+- Persist snippets across console sessions (default path: `tmp/rails_console_pro/snippets.yml`)
+- Fuzzy search by text or tags to quickly locate prior commands
+- Mark favorites for even faster recall
+- Use Ruby blocks to add multi-line snippets with nice formatting
+
+## Quick Actions
+
+```ruby
+# Capture a snippet
+snippets(:add, "User.where(active: true).count", description: "Active users", tags: %w[users metrics])
+
+# Capture multiline snippet with a block
+snippets(:add, description: "Backfill user slugs") do
+  <<~RUBY
+    User.where(slug: nil).find_each do |user|
+      user.update!(slug: user.name.parameterize)
+    end
+  RUBY
+end
+
+# List (defaults to the 10 most recent)
+snippets(:list)
+
+# Search by keyword
+snippets(:search, "active users")
+
+# Search by tags
+snippets(:search, tags: %w[metrics])
+
+# Mark a favorite and list favorites
+snippets(:favorite, "active-users")
+snippets(:list, favorites: true)
+
+# Show a specific snippet with full body
+snippets(:show, "active-users")
+
+# Remove a snippet
+snippets(:delete, "active-users")
+```
+
+## Configuration
+
+You can adjust snippet behavior via the standard configuration block:
+
+```ruby
+RailsConsolePro.configure do |config|
+  # Disable / enable the snippet commands
+  config.snippets_command_enabled = true
+
+  # Override the storage path if you prefer a shared location
+  config.snippet_store_path = Rails.root.join("tmp", "rails_console_pro", "snippets.yml")
+end
+```
+
+If you want to share snippets across a team, point `snippet_store_path` to a shared directory (for example within your repo) and commit the file if appropriate.
+
+## Tips
+
+- Use meaningful IDs (`id:` option) to recall snippets by name (`snippets(:show, "backfill-slugs")`)
+- Tag by model or domain (`tags: %w[user data-migrations]`) to quickly filter the list
+- Keep destructive snippets safe by adding warnings to the description or tags (`tags: %w[danger prod-only]`)
+- Since snippets are plain Ruby strings, you can paste them directly back into the console when you need them
+
+

data/lib/rails_console_pro/commands/jobs_command.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    class JobsCommand < BaseCommand
+      DEFAULT_LIMIT = 20
+
+      def execute(options = nil)
+        unless feature_enabled?
+          puts pastel.yellow("Jobs command is disabled. Enable it with: RailsConsolePro.configure { |c| c.queue_command_enabled = true }")
+          return nil
+        end
+
+        unless active_job_available?
+          puts pastel.red("ActiveJob is not loaded. Queue insights require ActiveJob to be available.")
+          return nil
+        end
+
+        normalized_options = normalize_options(options)
+
+        fetch_options, filter_options, action_options = split_options(normalized_options)
+        action_results = perform_actions(action_options, fetch_options)
+        action_results.each { |result| print_action_result(result) }
+
+        result = fetcher.fetch(**fetch_options)
+        return result unless result
+
+        apply_filters(result, filter_options)
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :jobs)
+      end
+
+      private
+
+      def feature_enabled?
+        RailsConsolePro.config.queue_command_enabled
+      end
+
+      def active_job_available?
+        defined?(ActiveJob::Base)
+      end
+
+      def fetcher
+        @fetcher ||= Services::QueueInsightFetcher.new
+      end
+
+      def action_service
+        @action_service ||= Services::QueueActionService.new
+      end
+
+      def perform_actions(action_options, fetch_options)
+        return [] if action_options.empty?
+
+        action_options.each_with_object([]) do |(action_key, value), results|
+          next if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+          result = action_service.perform(
+            action: action_key,
+            jid: value,
+            queue: fetch_options[:queue]
+          )
+          results << result if result
+        end
+      end
+
+      def apply_filters(result, filter_options)
+        filters = prepare_filters(filter_options)
+        filtered_enqueued = result.enqueued_jobs
+        filtered_retry = result.retry_jobs
+        filtered_recent = result.recent_executions
+        additional_warnings = []
+
+        statuses = filters[:statuses]
+        unless statuses.empty?
+          show_enqueued = statuses.include?(:enqueued) || statuses.include?(:scheduled) || statuses.include?(:all)
+          show_retry = statuses.include?(:retry) || statuses.include?(:retries) || statuses.include?(:all)
+          show_recent = statuses.include?(:recent) || statuses.include?(:executing) || statuses.include?(:running) || statuses.include?(:all)
+
+          filtered_enqueued = [] unless show_enqueued
+          filtered_retry = [] unless show_retry
+          filtered_recent = [] unless show_recent
+        end
+
+        if filters[:job_class]
+          matcher = filters[:job_class]
+          filtered_enqueued = filtered_enqueued.select { |job| job_class_matches?(job, matcher) }
+          filtered_retry = filtered_retry.select { |job| job_class_matches?(job, matcher) }
+          filtered_recent = filtered_recent.select { |job| job_class_matches?(job, matcher) }
+          if filtered_enqueued.empty? && filtered_retry.empty? && filtered_recent.empty?
+            additional_warnings << "No jobs matching class filter '#{matcher}'."
+          end
+        end
+
+        filtered_result = result.with_overrides(
+          enqueued_jobs: filtered_enqueued,
+          retry_jobs: filtered_retry,
+          recent_executions: filtered_recent,
+          warnings: result.warnings + additional_warnings
+        )
+
+        filtered_result
+      end
+
+      def normalize_options(options)
+        case options
+        when Numeric
+          { limit: options.to_i }
+        when Hash
+          symbolized = options.each_with_object({}) do |(key, value), acc|
+            sym_key = key.to_sym
+            sym_key = :job_class if sym_key == :class
+            acc[sym_key] = value
+          end
+          symbolized
+        when nil
+          {}
+        else
+          {}
+        end.then do |opts|
+          limit = opts.fetch(:limit, DEFAULT_LIMIT)
+          limit = limit.to_i
+          limit = DEFAULT_LIMIT if limit <= 0
+          opts[:limit] = limit
+          opts[:job_class] = opts[:job_class].to_s.strip if opts.key?(:job_class) && opts[:job_class]
+          [:retry, :delete, :details].each do |key|
+            opts[key] = opts[key].to_s.strip if opts.key?(key) && opts[key]
+          end
+          opts
+        end
+      end
+
+      def split_options(options)
+        fetch_options = {
+          limit: options[:limit],
+          queue: options[:queue]
+        }.compact
+
+        filter_options = {
+          statuses: options[:statuses] || options[:status],
+          job_class: options[:job_class]
+        }.compact
+
+        action_options = {
+          retry: options[:retry],
+          delete: options[:delete],
+          details: options[:details]
+        }.compact
+
+        [fetch_options, filter_options, action_options]
+      end
+
+      def prepare_filters(filter_options)
+        statuses =
+          Array(filter_options[:statuses]).flat_map { |s| s.to_s.split(',') }
+                                             .map(&:strip)
+                                             .reject(&:empty?)
+                                             .map { |s| s.downcase.to_sym }
+                                             .uniq
+
+        {
+          statuses: statuses,
+          job_class: filter_options[:job_class],
+          limit: filter_options[:limit]
+        }
+      end
+
+      def job_class_matches?(job, matcher)
+        job_class = job.job_class.to_s
+        return false if job_class.empty?
+
+        matcher_str = matcher.to_s
+        job_class.casecmp?(matcher_str) ||
+          job_class.split('::').last.casecmp?(matcher_str) ||
+          job_class.include?(matcher_str)
+      end
+
+      def print_action_result(result)
+        return unless result
+
+        if result.warning
+          puts pastel.yellow("⚠️  #{result.warning}")
+        end
+
+        if result.message
+          color_method = result.success ? :green : :cyan
+          puts pastel.public_send(color_method, result.message)
+        end
+
+        if result.details
+          puts pastel.cyan("Details:")
+          formatted = format_details(result.details)
+          puts formatted
+        end
+      end
+
+      def format_details(details)
+        case details
+        when String
+          "  #{details}"
+        when Hash
+          details.map { |key, value| "  #{key}: #{value.inspect}" }.join("\n")
+        when Array
+          details.map { |value| "  - #{value.inspect}" }.join("\n")
+        else
+          details.inspect
+        end
+      end
+    end
+  end
+end
+
+

data/lib/rails_console_pro/commands/profile_command.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RailsConsolePro
+  module Commands
+    # Command for profiling arbitrary blocks, callables, or ActiveRecord relations
+    class ProfileCommand < BaseCommand
+      def execute(target = nil, *args, label: nil, &block)
+        return disabled_message unless enabled?
+
+        label, target, block = normalize_arguments(label, target, block)
+        execution = build_execution(target, args, block)
+        return execution if execution.nil? || execution.is_a?(String)
+
+        collector = Services::ProfileCollector.new(config)
+        collector.profile(label: label || execution[:label]) do
+          execution[:callable].call
+        end
+      rescue => e
+        RailsConsolePro::ErrorHandler.handle(e, context: :profile)
+      end
+
+      private
+
+      def enabled?
+        RailsConsolePro.config.enabled && RailsConsolePro.config.profile_command_enabled
+      end
+
+      def disabled_message
+        pastel.yellow('Profile command is disabled. Enable it via RailsConsolePro.configure { |c| c.profile_command_enabled = true }')
+      end
+
+      def config
+        RailsConsolePro.config
+      end
+
+      def normalize_arguments(label, target, block)
+        if block_provided?(block) && (target.is_a?(String) || target.is_a?(Symbol))
+          label ||= target.to_s
+          target = nil
+        end
+        [label, target, block]
+      end
+
+      def block_provided?(block)
+        !block.nil?
+      end
+
+      def build_execution(target, args, block)
+        if block_provided?(block)
+          { callable: block, label: nil }
+        elsif relation?(target)
+          relation = target
+          { callable: -> { relation.load }, label: "#{relation.klass.name} relation" }
+        elsif callable?(target)
+          callable = target
+          { callable: -> { callable.call(*args) }, label: callable_label(callable) }
+        elsif target.nil?
+          pastel.red('Nothing to profile. Provide a block, callable, or ActiveRecord relation.')
+        else
+          { callable: -> { target }, label: target.class.name }
+        end
+      end
+
+      def relation?(object)
+        defined?(ActiveRecord::Relation) && object.is_a?(ActiveRecord::Relation)
+      end
+
+      def callable?(object)
+        object.respond_to?(:call)
+      end
+
+      def callable_label(callable)
+        if callable.respond_to?(:name) && callable.name
+          callable.name
+        elsif callable.respond_to?(:receiver) && callable.respond_to?(:name)
+          "#{callable.receiver.class}##{callable.name}"
+        else
+          callable.class.name
+        end
+      end
+    end
+  end
+end
+