ruby_llm-agents 0.1.0

data/app/channels/ruby_llm/agents/executions_channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # ActionCable channel for real-time execution updates
+    #
+    # Broadcasts execution create/update events to subscribed clients.
+    # Used by the dashboard to show live execution status changes.
+    #
+    # Inherits from the host app's ApplicationCable::Channel (note the :: prefix)
+    #
+    class ExecutionsChannel < ::ApplicationCable::Channel
+      def subscribed
+        stream_from "ruby_llm_agents:executions"
+        logger.info "[RubyLLM::Agents] Client subscribed to executions channel"
+      end
+
+      def unsubscribed
+        logger.info "[RubyLLM::Agents] Client unsubscribed from executions channel"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class AgentsController < ApplicationController
+      def index
+        @agents = AgentRegistry.all_with_details
+      end
+
+      def show
+        @agent_type = params[:id]
+        @agent_class = AgentRegistry.find(@agent_type)
+        @agent_active = @agent_class.present?
+
+        # Get stats for different time periods
+        @stats = Execution.stats_for(@agent_type, period: :all_time)
+        @stats_today = Execution.stats_for(@agent_type, period: :today)
+
+        # Get available filter options for this agent
+        @versions = Execution.by_agent(@agent_type).distinct.pluck(:agent_version).compact.sort.reverse
+        @models = Execution.by_agent(@agent_type).distinct.pluck(:model_id).compact.sort
+        @temperatures = Execution.by_agent(@agent_type).distinct.pluck(:temperature).compact.sort
+
+        # Build filtered scope
+        base_scope = Execution.by_agent(@agent_type)
+
+        # Apply status filter
+        if params[:statuses].present?
+          statuses = params[:statuses].is_a?(Array) ? params[:statuses] : params[:statuses].split(",")
+          base_scope = base_scope.where(status: statuses) if statuses.any?(&:present?)
+        end
+
+        # Apply version filter
+        if params[:versions].present?
+          versions = params[:versions].is_a?(Array) ? params[:versions] : params[:versions].split(",")
+          base_scope = base_scope.where(agent_version: versions) if versions.any?(&:present?)
+        end
+
+        # Apply model filter
+        if params[:models].present?
+          models = params[:models].is_a?(Array) ? params[:models] : params[:models].split(",")
+          base_scope = base_scope.where(model_id: models) if models.any?(&:present?)
+        end
+
+        # Apply temperature filter
+        if params[:temperatures].present?
+          temps = params[:temperatures].is_a?(Array) ? params[:temperatures] : params[:temperatures].split(",")
+          base_scope = base_scope.where(temperature: temps) if temps.any?(&:present?)
+        end
+
+        # Apply time range filter
+        base_scope = base_scope.where("created_at >= ?", params[:days].to_i.days.ago) if params[:days].present?
+
+        # Paginate
+        page = (params[:page] || 1).to_i
+        per_page = 25
+        offset = (page - 1) * per_page
+
+        filtered_scope = base_scope.order(created_at: :desc)
+        total_count = filtered_scope.count
+        @executions = filtered_scope.limit(per_page).offset(offset)
+
+        @pagination = {
+          current_page: page,
+          per_page: per_page,
+          total_count: total_count,
+          total_pages: (total_count.to_f / per_page).ceil
+        }
+
+        # Filter stats for summary display
+        @filter_stats = {
+          total_count: total_count,
+          total_cost: base_scope.sum(:total_cost),
+          total_tokens: base_scope.sum(:total_tokens)
+        }
+
+        # Get trend data for charts (30 days)
+        @trend_data = Execution.trend_analysis(agent_type: @agent_type, days: 30)
+
+        # Get status distribution for pie chart
+        @status_distribution = Execution.by_agent(@agent_type)
+                                         .group(:status)
+                                         .count
+
+        # Agent configuration (if class exists)
+        if @agent_class
+          @config = {
+            model: @agent_class.model,
+            temperature: @agent_class.temperature,
+            version: @agent_class.version,
+            timeout: @agent_class.timeout,
+            cache_enabled: @agent_class.cache_enabled?,
+            cache_ttl: @agent_class.cache_ttl,
+            params: @agent_class.params
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class ApplicationController < ActionController::Base
+      layout "rubyllm/agents/application"
+
+      before_action :authenticate_dashboard!
+
+      private
+
+      def authenticate_dashboard!
+        auth_proc = RubyLLM::Agents.configuration.dashboard_auth
+        return if auth_proc.call(self)
+
+        render plain: "Unauthorized", status: :unauthorized
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class DashboardController < ApplicationController
+      def index
+        @stats = daily_stats
+        @recent_executions = Execution.recent(10)
+        @hourly_activity = Execution.hourly_activity_chart
+      end
+
+      private
+
+      def daily_stats
+        scope = Execution.today
+        {
+          total_executions: scope.count,
+          successful: scope.successful.count,
+          failed: scope.failed.count,
+          total_cost: scope.total_cost_sum || 0,
+          total_tokens: scope.total_tokens_sum || 0,
+          avg_duration_ms: scope.avg_duration&.round || 0,
+          success_rate: calculate_success_rate(scope)
+        }
+      end
+
+      def calculate_success_rate(scope)
+        total = scope.count
+        return 0.0 if total.zero?
+        (scope.successful.count.to_f / total * 100).round(1)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    class ExecutionsController < ApplicationController
+      def index
+        @agent_types = Execution.distinct.pluck(:agent_type)
+        @statuses = Execution.statuses.keys
+        load_paginated_executions
+        load_filter_stats
+
+        respond_to do |format|
+          format.html
+          format.turbo_stream
+        end
+      end
+
+      def show
+        @execution = Execution.find(params[:id])
+      end
+
+      def search
+        @agent_types = Execution.distinct.pluck(:agent_type)
+        @statuses = Execution.statuses.keys
+        load_paginated_executions
+        load_filter_stats
+
+        respond_to do |format|
+          format.html { render :index }
+          format.turbo_stream do
+            render turbo_stream: turbo_stream.replace(
+              "executions_list",
+              partial: "ruby_llm/agents/executions/list",
+              locals: { executions: @executions, pagination: @pagination, filter_stats: @filter_stats }
+            )
+          end
+        end
+      end
+
+      private
+
+      def load_paginated_executions
+        page = (params[:page] || 1).to_i
+        per_page = 25
+        offset = (page - 1) * per_page
+
+        base_scope = filtered_executions.order(created_at: :desc)
+        total_count = base_scope.count
+        @executions = base_scope.limit(per_page).offset(offset)
+
+        @pagination = {
+          current_page: page,
+          per_page: per_page,
+          total_count: total_count,
+          total_pages: (total_count.to_f / per_page).ceil
+        }
+      end
+
+      def load_filter_stats
+        scope = filtered_executions
+        @filter_stats = {
+          total_count: scope.count,
+          total_cost: scope.sum(:total_cost) || 0,
+          total_tokens: scope.sum(:total_tokens) || 0
+        }
+      end
+
+      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?)
+        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?)
+        elsif params[:status].present?
+          scope = scope.where(status: params[:status])
+        end
+
+        scope = scope.where("created_at >= ?", params[:days].to_i.days.ago) if params[:days].present?
+
+        scope
+      end
+    end
+  end
+end

data/app/helpers/ruby_llm/agents/application_helper.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    module ApplicationHelper
+      include Chartkick::Helper if defined?(Chartkick)
+
+      def ruby_llm_agents
+        RubyLLM::Agents::Engine.routes.url_helpers
+      end
+
+      def number_to_human_short(number, prefix: nil, precision: 1)
+        return "#{prefix}0" if number.nil? || number.zero?
+
+        abs_number = number.to_f.abs
+        formatted = if abs_number >= 1_000_000_000
+          "#{(number / 1_000_000_000.0).round(precision)}B"
+        elsif abs_number >= 1_000_000
+          "#{(number / 1_000_000.0).round(precision)}M"
+        elsif abs_number >= 1_000
+          "#{(number / 1_000.0).round(precision)}K"
+        elsif abs_number < 1 && abs_number > 0
+          number.round(precision + 3).to_s
+        else
+          number.round(precision).to_s
+        end
+
+        "#{prefix}#{formatted}"
+      end
+
+      def highlight_json(obj)
+        return "" if obj.nil?
+
+        json_string = JSON.pretty_generate(obj)
+        highlight_json_string(json_string)
+      end
+
+      def highlight_json_string(json_string)
+        return "" if json_string.blank?
+
+        tokens = []
+        i = 0
+        chars = json_string.chars
+
+        while i < chars.length
+          char = chars[i]
+
+          case char
+          when '"'
+            # Parse string
+            str_start = i
+            i += 1
+            while i < chars.length
+              if chars[i] == '\\'
+                i += 2
+              elsif chars[i] == '"'
+                i += 1
+                break
+              else
+                i += 1
+              end
+            end
+            tokens << { type: :string, value: chars[str_start...i].join }
+          when /[0-9\-]/
+            # Parse number
+            num_start = i
+            i += 1
+            while i < chars.length && chars[i] =~ /[0-9.eE+\-]/
+              i += 1
+            end
+            tokens << { type: :number, value: chars[num_start...i].join }
+          when 't'
+            # true
+            if chars[i, 4].join == 'true'
+              tokens << { type: :boolean, value: 'true' }
+              i += 4
+            else
+              tokens << { type: :text, value: char }
+              i += 1
+            end
+          when 'f'
+            # false
+            if chars[i, 5].join == 'false'
+              tokens << { type: :boolean, value: 'false' }
+              i += 5
+            else
+              tokens << { type: :text, value: char }
+              i += 1
+            end
+          when 'n'
+            # null
+            if chars[i, 4].join == 'null'
+              tokens << { type: :null, value: 'null' }
+              i += 4
+            else
+              tokens << { type: :text, value: char }
+              i += 1
+            end
+          when ':', ',', '{', '}', '[', ']', ' ', "\n", "\t"
+            tokens << { type: :punct, value: char }
+            i += 1
+          else
+            tokens << { type: :text, value: char }
+            i += 1
+          end
+        end
+
+        # Build highlighted HTML - detect if string is a key (followed by :)
+        result = []
+        tokens.each_with_index do |token, idx|
+          case token[:type]
+          when :string
+            # Check if this is a key (next non-whitespace token is :)
+            is_key = false
+            (idx + 1...tokens.length).each do |j|
+              if tokens[j][:type] == :punct
+                if tokens[j][:value] == ':'
+                  is_key = true
+                  break
+                elsif tokens[j][:value] !~ /\s/
+                  break
+                end
+              else
+                break
+              end
+            end
+
+            escaped_value = ERB::Util.html_escape(token[:value])
+            if is_key
+              result << %(<span class="text-purple-600">#{escaped_value}</span>)
+            else
+              result << %(<span class="text-green-600">#{escaped_value}</span>)
+            end
+          when :number
+            result << %(<span class="text-blue-600">#{token[:value]}</span>)
+          when :boolean
+            result << %(<span class="text-amber-600">#{token[:value]}</span>)
+          when :null
+            result << %(<span class="text-gray-400">#{token[:value]}</span>)
+          else
+            result << ERB::Util.html_escape(token[:value])
+          end
+        end
+
+        result.join.html_safe
+      end
+    end
+  end
+end

data/app/javascript/ruby_llm/agents/controllers/filter_controller.js

@@ -0,0 +1,56 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Filter controller for live filtering of executions
+//
+// Usage:
+//   <form data-controller="filter">
+//     <select data-action="change->filter#submit">...</select>
+//   </form>
+//
+export default class extends Controller {
+  static targets = ["form"]
+  static values = {
+    debounce: { type: Number, default: 300 }
+  }
+
+  connect() {
+    this.timeout = null
+  }
+
+  disconnect() {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+    }
+  }
+
+  // Submit the form with debouncing
+  submit(event) {
+    if (this.timeout) {
+      clearTimeout(this.timeout)
+    }
+
+    this.timeout = setTimeout(() => {
+      this.element.requestSubmit()
+    }, this.debounceValue)
+  }
+
+  // Submit immediately without debounce
+  submitNow(event) {
+    this.element.requestSubmit()
+  }
+
+  // Update URL with current filter state
+  updateUrl() {
+    const formData = new FormData(this.element)
+    const params = new URLSearchParams()
+
+    for (const [key, value] of formData) {
+      if (value) {
+        params.set(key, value)
+      }
+    }
+
+    const newUrl = `${window.location.pathname}?${params.toString()}`
+    window.history.pushState({}, "", newUrl)
+  }
+}

data/app/javascript/ruby_llm/agents/controllers/index.js

@@ -0,0 +1,12 @@
+// Entry point for RubyLLM::Agents Stimulus controllers
+// Import and register controllers with your Stimulus application
+
+import FilterController from "./filter_controller"
+import RefreshController from "./refresh_controller"
+
+export { FilterController, RefreshController }
+
+export function registerControllers(application) {
+  application.register("filter", FilterController)
+  application.register("refresh", RefreshController)
+}

data/app/javascript/ruby_llm/agents/controllers/refresh_controller.js

@@ -0,0 +1,83 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Auto-refresh controller for dashboard with toggle support
+//
+// Usage:
+//   <div data-controller="refresh"
+//        data-refresh-interval-value="30000"
+//        data-refresh-enabled-value="false">
+//     <button data-action="refresh#toggle" data-refresh-target="button">
+//       Live Poll: Off
+//     </button>
+//   </div>
+//
+export default class extends Controller {
+  static values = {
+    interval: { type: Number, default: 30000 },
+    enabled: { type: Boolean, default: false }
+  }
+
+  static targets = ["button", "indicator"]
+
+  connect() {
+    this.updateUI()
+    if (this.enabledValue) {
+      this.startRefresh()
+    }
+  }
+
+  disconnect() {
+    this.stopRefresh()
+  }
+
+  toggle() {
+    this.enabledValue = !this.enabledValue
+
+    if (this.enabledValue) {
+      this.startRefresh()
+      this.refresh() // Immediate refresh when enabled
+    } else {
+      this.stopRefresh()
+    }
+
+    this.updateUI()
+  }
+
+  startRefresh() {
+    if (this.intervalValue > 0 && !this.timer) {
+      this.timer = setInterval(() => this.refresh(), this.intervalValue)
+    }
+  }
+
+  stopRefresh() {
+    if (this.timer) {
+      clearInterval(this.timer)
+      this.timer = null
+    }
+  }
+
+  refresh() {
+    const frame = this.element.closest("turbo-frame") ||
+                  this.element.querySelector("turbo-frame")
+
+    if (frame && typeof frame.reload === "function") {
+      frame.reload()
+    }
+  }
+
+  updateUI() {
+    if (this.hasButtonTarget) {
+      if (this.enabledValue) {
+        this.buttonTarget.classList.remove("bg-gray-100", "text-gray-600")
+        this.buttonTarget.classList.add("bg-green-100", "text-green-700")
+      } else {
+        this.buttonTarget.classList.remove("bg-green-100", "text-green-700")
+        this.buttonTarget.classList.add("bg-gray-100", "text-gray-600")
+      }
+    }
+
+    if (this.hasIndicatorTarget) {
+      this.indicatorTarget.textContent = this.enabledValue ? "On" : "Off"
+    }
+  }
+}