ruby_llm-agents 0.2.3 → 0.3.0

data/app/controllers/ruby_llm/agents/executions_controller.rb

@@ -2,12 +2,28 @@
 
 module RubyLLM
   module Agents
+    # Controller for browsing and searching execution records
+    #
+    # Provides paginated listing, filtering, and detail views for all
+    # agent executions. Supports both HTML and Turbo Stream responses
+    # for seamless filtering without full page reloads.
+    #
+    # @see Paginatable For pagination implementation
+    # @see Filterable For filter parsing and validation
+    # @api private
     class ExecutionsController < ApplicationController
+      include Paginatable
+      include Filterable
+
+      CSV_COLUMNS = %w[id agent_type agent_version status model_id total_tokens total_cost
+                       duration_ms created_at error_class error_message].freeze
+
+      # Lists all executions with filtering and pagination
+      #
+      # @return [void]
       def index
-        @agent_types = Execution.distinct.pluck(:agent_type)
-        @statuses = Execution.statuses.keys
-        load_paginated_executions
-        load_filter_stats
+        load_filter_options
+        load_executions_with_stats
 
         respond_to do |format|
           format.html
@@ -15,15 +31,22 @@ module RubyLLM
         end
       end
 
+      # Shows a single execution's details
+      #
+      # @return [void]
       def show
         @execution = Execution.find(params[:id])
       end
 
+      # Handles filter search requests via Turbo Stream
+      #
+      # Returns the same data as index but optimized for AJAX/Turbo
+      # requests, replacing only the executions list partial.
+      #
+      # @return [void]
       def search
-        @agent_types = Execution.distinct.pluck(:agent_type)
-        @statuses = Execution.statuses.keys
-        load_paginated_executions
-        load_filter_stats
+        load_filter_options
+        load_executions_with_stats
 
         respond_to do |format|
           format.html { render :index }
@@ -37,25 +60,145 @@ module RubyLLM
         end
       end
 
+      # Reruns an execution with the same parameters
+      #
+      # Supports both dry-run mode (returns prompt info without API call)
+      # and real reruns that create a new execution.
+      #
+      # @return [void]
+      def rerun
+        @execution = Execution.find(params[:id])
+        dry_run = params[:dry_run] == "true"
+
+        agent_class = AgentRegistry.find(@execution.agent_type)
+
+        unless agent_class
+          flash[:alert] = "Agent class '#{@execution.agent_type}' not found. Cannot rerun."
+          redirect_to execution_path(@execution)
+          return
+        end
+
+        # Prepare parameters from original execution
+        original_params = @execution.parameters&.symbolize_keys || {}
+
+        if dry_run
+          # Dry run mode - show what would be sent without making API call
+          result = agent_class.call(**original_params, dry_run: true)
+          @dry_run_result = result
+
+          respond_to do |format|
+            format.html { render :dry_run }
+            format.json { render json: result }
+          end
+        else
+          # Real rerun - execute the agent
+          begin
+            agent_class.call(**original_params)
+            flash[:notice] = "Execution rerun successfully! Check the executions list for the new result."
+          rescue StandardError => e
+            flash[:alert] = "Rerun failed: #{e.message}"
+          end
+
+          redirect_to executions_path
+        end
+      end
+
+      # Exports filtered executions as CSV
+      #
+      # Streams CSV data with redacted error messages to protect
+      # sensitive information. Respects all current filter parameters.
+      #
+      # @return [void]
+      def export
+        filename = "executions-#{Date.current.iso8601}.csv"
+
+        headers["Content-Type"] = "text/csv"
+        headers["Content-Disposition"] = "attachment; filename=\"#{filename}\""
+
+        response.status = 200
+
+        self.response_body = Enumerator.new do |yielder|
+          yielder << CSV.generate_line(CSV_COLUMNS)
+
+          filtered_executions.find_each(batch_size: 1000) do |execution|
+            yielder << generate_csv_row(execution)
+          end
+        end
+      end
+
       private
 
-      def load_paginated_executions
-        page = (params[:page] || 1).to_i
-        per_page = 25
-        offset = (page - 1) * per_page
+      # Generates a CSV row for a single execution with redacted values
+      #
+      # @param execution [Execution] The execution record
+      # @return [String] CSV row string
+      def generate_csv_row(execution)
+        redacted_error_message = if execution.error_message.present?
+                                   Redactor.redact_string(execution.error_message)
+                                 end
 
-        base_scope = filtered_executions.order(created_at: :desc)
-        total_count = base_scope.count
-        @executions = base_scope.limit(per_page).offset(offset)
+        CSV.generate_line([
+          execution.id,
+          execution.agent_type,
+          execution.agent_version,
+          execution.status,
+          execution.model_id,
+          execution.total_tokens,
+          execution.total_cost&.to_f,
+          execution.duration_ms,
+          execution.created_at.iso8601,
+          execution.error_class,
+          redacted_error_message
+        ])
+      end
 
-        @pagination = {
-          current_page: page,
-          per_page: per_page,
-          total_count: total_count,
-          total_pages: (total_count.to_f / per_page).ceil
-        }
+      # Loads available options for filter dropdowns
+      #
+      # Populates @agent_types with all agent types that have executions,
+      # @model_ids with all distinct models used, and @statuses with all
+      # possible status values.
+      #
+      # @return [void]
+      def load_filter_options
+        @agent_types = available_agent_types
+        @model_ids = available_model_ids
+        @statuses = Execution.statuses.keys
       end
 
+      # Returns distinct agent types from execution history
+      #
+      # Memoized to avoid duplicate queries within a request.
+      #
+      # @return [Array<String>] Agent type names
+      def available_agent_types
+        @available_agent_types ||= Execution.distinct.pluck(:agent_type)
+      end
+
+      # Returns distinct model IDs from execution history
+      #
+      # Memoized to avoid duplicate queries within a request.
+      #
+      # @return [Array<String>] Model IDs
+      def available_model_ids
+        @available_model_ids ||= Execution.where.not(model_id: nil).distinct.pluck(:model_id).sort
+      end
+
+      # Loads paginated executions and associated statistics
+      #
+      # Sets @executions, @pagination, and @filter_stats instance variables
+      # for use in views.
+      #
+      # @return [void]
+      def load_executions_with_stats
+        result = paginate(filtered_executions)
+        @executions = result[:records]
+        @pagination = result[:pagination]
+        load_filter_stats
+      end
+
+      # Calculates aggregate statistics for the current filter
+      #
+      # @return [void]
       def load_filter_stats
         scope = filtered_executions
         @filter_stats = {
@@ -65,26 +208,41 @@ module RubyLLM
         }
       end
 
+      # Builds a filtered execution scope based on request params
+      #
+      # Applies filters in order: search, agent type, status, then time range.
+      # Each filter is optional and validated before application.
+      #
+      # @return [ActiveRecord::Relation] Filtered execution scope
       def filtered_executions
         scope = Execution.all
 
-        # Support multiple agent types (comma-separated or array)
-        if params[:agent_types].present?
-          agent_types = params[:agent_types].is_a?(Array) ? params[:agent_types] : params[:agent_types].split(",")
-          scope = scope.where(agent_type: agent_types) if agent_types.any?(&:present?)
+        # Apply search filter
+        scope = scope.search(params[:q]) if params[:q].present?
+
+        # Apply agent type filter
+        agent_types = parse_array_param(:agent_types)
+        if agent_types.any?
+          scope = scope.where(agent_type: agent_types)
         elsif params[:agent_type].present?
           scope = scope.by_agent(params[:agent_type])
         end
 
-        # Support multiple statuses (comma-separated or array)
-        if params[:statuses].present?
-          statuses = params[:statuses].is_a?(Array) ? params[:statuses] : params[:statuses].split(",")
-          scope = scope.where(status: statuses) if statuses.any?(&:present?)
+        # Apply status filter with validation
+        statuses = parse_array_param(:statuses)
+        if statuses.any?
+          scope = apply_status_filter(scope, statuses)
         elsif params[:status].present?
-          scope = scope.where(status: params[:status])
+          scope = apply_status_filter(scope, [params[:status]])
         end
 
-        scope = scope.where("created_at >= ?", params[:days].to_i.days.ago) if params[:days].present?
+        # Apply time filter with validation
+        days = parse_days_param
+        scope = apply_time_filter(scope, days)
+
+        # Apply model filter
+        model_ids = parse_array_param(:model_ids)
+        scope = scope.where(model_id: model_ids) if model_ids.any?
 
         scope
       end

data/app/controllers/ruby_llm/agents/settings_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Controller for displaying global configuration settings
+    #
+    # Shows all configuration options from RubyLLM::Agents.configuration
+    # in a read-only dashboard view.
+    #
+    # @api private
+    class SettingsController < ApplicationController
+      # Displays the global configuration settings
+      #
+      # @return [void]
+      def show
+        @config = RubyLLM::Agents.configuration
+      end
+    end
+  end
+end