rubyllm-observ 0.5.0

data/app/controllers/observ/prompt_versions_controller.rb

@@ -0,0 +1,148 @@
+module Observ
+  class PromptVersionsController < ApplicationController
+    before_action :set_prompt_name
+    before_action :set_prompt
+
+    # GET /observ/prompts/:prompt_id/versions/:id
+    def show
+      redirect_to prompt_path(@prompt_name, version: @prompt.version)
+    end
+
+    # POST /observ/prompts/:prompt_id/versions/:id/promote
+    def promote
+      unless @prompt.draft?
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name, version: @prompt.version),
+              alert: "Only draft prompts can be promoted"
+          end
+          format.json { render json: { error: "Only draft prompts can be promoted" }, status: :unprocessable_content }
+        end
+        return
+      end
+
+      begin
+        Observ::PromptManager.promote(name: @prompt_name, version: @prompt.version)
+
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name),
+              notice: "Version #{@prompt.version} promoted to production"
+          end
+          format.json { render json: { success: true, message: "Promoted to production" } }
+        end
+      rescue StandardError => e
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name, version: @prompt.version),
+              alert: e.message
+          end
+          format.json { render json: { error: e.message }, status: :unprocessable_content }
+        end
+      end
+    end
+
+    # POST /observ/prompts/:prompt_id/versions/:id/demote
+    def demote
+      unless @prompt.production?
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name, version: @prompt.version),
+              alert: "Only production prompts can be demoted"
+          end
+          format.json { render json: { error: "Only production prompts can be demoted" }, status: :unprocessable_content }
+        end
+        return
+      end
+
+      begin
+        Observ::PromptManager.demote(name: @prompt_name, version: @prompt.version)
+
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name),
+              notice: "Version #{@prompt.version} demoted to archived"
+          end
+          format.json { render json: { success: true, message: "Demoted to archived" } }
+        end
+      rescue StandardError => e
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name, version: @prompt.version),
+              alert: e.message
+          end
+          format.json { render json: { error: e.message }, status: :unprocessable_content }
+        end
+      end
+    end
+
+    # POST /observ/prompts/:prompt_id/versions/:id/restore
+    def restore
+      unless @prompt.archived?
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name, version: @prompt.version),
+              alert: "Only archived prompts can be restored"
+          end
+          format.json { render json: { error: "Only archived prompts can be restored" }, status: :unprocessable_content }
+        end
+        return
+      end
+
+      begin
+        Observ::PromptManager.restore(name: @prompt_name, version: @prompt.version)
+
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name),
+              notice: "Version #{@prompt.version} restored to production"
+          end
+          format.json { render json: { success: true, message: "Restored to production" } }
+        end
+      rescue StandardError => e
+        respond_to do |format|
+          format.html do
+            redirect_to prompt_path(@prompt_name, version: @prompt.version),
+              alert: e.message
+          end
+          format.json { render json: { error: e.message }, status: :unprocessable_content }
+        end
+      end
+    end
+
+    # POST /observ/prompts/:prompt_id/versions/:id/clone
+    def clone
+      # Production and archived prompts are immutable - clone to draft for editing
+      begin
+        new_prompt = Observ::PromptManager.create(
+          name: @prompt_name,
+          prompt: @prompt.prompt,
+          config: @prompt.config,
+          commit_message: "Cloned from version #{@prompt.version}",
+          created_by: current_user_identifier,
+          promote_to_production: false
+        )
+
+        redirect_to edit_prompt_path(@prompt_name, version: new_prompt.version),
+          notice: "Created editable draft (v#{new_prompt.version}) from version #{@prompt.version}"
+      rescue ActiveRecord::RecordInvalid, StandardError => e
+        redirect_to prompt_path(@prompt_name, version: @prompt.version),
+          alert: e.message
+      end
+    end
+
+    private
+
+    def set_prompt_name
+      @prompt_name = params[:prompt_id]
+    end
+
+    def set_prompt
+      @prompt = Observ::Prompt.find(params[:id])
+    end
+
+    def current_user_identifier
+      "system" # Default fallback
+    end
+  end
+end

data/app/controllers/observ/prompts_controller.rb

@@ -0,0 +1,205 @@
+module Observ
+  class PromptsController < ApplicationController
+    before_action :set_prompt_name, only: [ :show, :edit, :update, :destroy, :versions, :compare ]
+    before_action :set_prompt, only: [ :edit, :update, :destroy ]
+
+    # GET /observ/prompts
+    def index
+      @prompts = Observ::Prompt.select(:name)
+        .distinct
+        .order(:name)
+
+      # Apply search filter
+      if params[:search].present?
+        @prompts = @prompts.where("name LIKE ? COLLATE NOCASE", "%#{params[:search]}%")
+      end
+
+      # Apply state filter
+      if params[:state].present?
+        @prompts = @prompts.where(state: params[:state])
+      end
+
+      @prompts = @prompts.page(params[:page]).per(Observ.config.pagination_per_page)
+
+      # Enrich with metadata for display
+      @prompt_data = @prompts.map do |prompt|
+        latest = Observ::Prompt.where(name: prompt.name).order(version: :desc).first
+        production = Observ::Prompt.where(name: prompt.name, state: :production).first
+
+        {
+          name: prompt.name,
+          total_versions: Observ::Prompt.where(name: prompt.name).count,
+          production_version: production&.version,
+          latest_version: latest.version,
+          latest_state: latest.state,
+          last_updated: latest.updated_at,
+          has_draft: Observ::Prompt.where(name: prompt.name, state: :draft).exists?
+        }
+      end
+    end
+
+    # GET /observ/prompts/new
+    def new
+      @form = Observ::PromptForm.new(
+        name: params[:name],
+        from_version: params[:from_version]
+      )
+    end
+
+    # POST /observ/prompts
+    def create
+      @form = Observ::PromptForm.new(form_params)
+      @form.created_by = current_user_identifier
+
+      if @form.save
+        redirect_to prompt_path(@form.persisted_prompt.name),
+          notice: "Prompt created successfully (v#{@form.persisted_prompt.version})"
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    # GET /observ/prompts/:id
+    def show
+      # Get production version by default, or latest version if no production
+      @prompt = Observ::Prompt.where(name: @prompt_name, state: :production).first ||
+                Observ::Prompt.where(name: @prompt_name).order(version: :desc).first
+
+      unless @prompt
+        redirect_to prompts_path, alert: "Prompt not found"
+        return
+      end
+
+      # Load specific version if requested
+      if params[:version].present?
+        @prompt = Observ::Prompt.find_by(name: @prompt_name, version: params[:version])
+        unless @prompt
+          redirect_to prompt_path(@prompt_name), alert: "Version not found"
+          return
+        end
+      end
+
+      @all_versions = Observ::Prompt.where(name: @prompt_name).order(version: :desc)
+      @production_version = @all_versions.find(&:production?)
+    end
+
+    # GET /observ/prompts/:id/edit
+    def edit
+      # Only draft prompts can be edited
+      unless @prompt.draft?
+        redirect_to prompt_path(@prompt_name),
+          alert: "Only draft prompts can be edited. Clone this version to create an editable draft."
+      end
+    end
+
+    # PATCH /observ/prompts/:id
+    def update
+      unless @prompt.draft?
+        redirect_to prompt_path(@prompt_name),
+          alert: "Only draft prompts can be edited"
+        return
+      end
+
+      # Parse config JSON string before updating
+      update_params = prompt_params.except(:name, :version, :promote_to_production)
+      if update_params[:config].present?
+        update_params[:config] = parse_config(update_params[:config])
+      end
+
+      if @prompt.update(update_params)
+        redirect_to prompt_path(@prompt_name, version: @prompt.version),
+          notice: "Prompt updated successfully"
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    # DELETE /observ/prompts/:id
+    def destroy
+      # Can only delete draft and archived prompts
+      if @prompt.production?
+        redirect_to prompt_path(@prompt_name),
+          alert: "Cannot delete production prompts"
+        return
+      end
+
+      @prompt.destroy
+      redirect_to prompts_path, notice: "Prompt version #{@prompt.version} deleted"
+    end
+
+    # GET /observ/prompts/:id/versions
+    def versions
+      @versions = Observ::Prompt.where(name: @prompt_name).order(version: :desc)
+      @production_version = @versions.find(&:production?)
+
+      respond_to do |format|
+        format.html # Render the HTML view
+        format.json do
+          render json: @versions.as_json(only: [ :version, :state, :commit_message, :created_at ])
+        end
+      end
+    end
+
+    # GET /observ/prompts/:id/compare?from=1&to=2
+    def compare
+      @from_version = Observ::Prompt.find_by(name: @prompt_name, version: params[:from])
+      @to_version = Observ::Prompt.find_by(name: @prompt_name, version: params[:to])
+
+      unless @from_version && @to_version
+        redirect_to versions_prompt_path(@prompt_name),
+          alert: "Both versions must be specified"
+        return
+      end
+
+      @diff = calculate_diff(@from_version.prompt, @to_version.prompt)
+    end
+
+    private
+
+    def set_prompt_name
+      @prompt_name = params[:id] || params[:name]
+    end
+
+    def set_prompt
+      version = params[:version] || Observ::Prompt.where(name: @prompt_name, state: :draft).maximum(:version)
+      @prompt = Observ::Prompt.find_by!(name: @prompt_name, version: version)
+    end
+
+    def prompt_params
+      params.require(:observ_prompt).permit(
+        :name, :prompt, :config, :commit_message, :promote_to_production
+      )
+    end
+
+    def form_params
+      params.require(:observ_prompt_form).permit(
+        :name, :prompt, :config, :commit_message, :promote_to_production, :from_version
+      )
+    end
+
+    def parse_config(config_string)
+      return {} if config_string.blank?
+      JSON.parse(config_string)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def current_user_identifier
+      # Implement based on your authentication system
+      "system" # Default fallback
+    end
+
+    def calculate_diff(text1, text2)
+      # Simple line-by-line diff
+      # In production, consider using gems like 'diffy' or 'diff-lcs'
+      lines1 = text1.split("\n")
+      lines2 = text2.split("\n")
+
+      {
+        removed: lines1 - lines2,
+        added: lines2 - lines1,
+        common: lines1 & lines2
+      }
+    end
+  end
+end

data/app/controllers/observ/sessions_controller.rb

@@ -0,0 +1,45 @@
+module Observ
+  class SessionsController < ApplicationController
+    def index
+      @sessions = Observ::Session.order(start_time: :desc)
+      apply_filters if params[:filter].present?
+      @sessions = @sessions.page(params[:page]).per(Observ.config.pagination_per_page)
+    end
+
+    def show
+      @session = Observ::Session.find(params[:id])
+      @traces = @session.traces.order(start_time: :asc)
+      @session_metrics = @session.session_metrics
+      @chat = @session.chat
+    end
+
+    def metrics
+      @session = Observ::Session.find(params[:id])
+      render json: @session.session_metrics
+    end
+
+    def drawer_test
+      @session = Observ::Session.find(params[:id])
+    end
+
+    def annotations_drawer
+      @session = Observ::Session.find(params[:id])
+      @annotations = @session.annotations.recent
+      @annotation = @session.annotations.build
+    end
+
+    private
+
+    def apply_filters
+      @sessions = @sessions.where(user_id: params[:filter][:user_id]) if params[:filter][:user_id].present?
+
+      if params[:filter][:start_date].present?
+        @sessions = @sessions.where("start_time >= ?", params[:filter][:start_date])
+      end
+
+      if params[:filter][:end_date].present?
+        @sessions = @sessions.where("start_time <= ?", params[:filter][:end_date])
+      end
+    end
+  end
+end

data/app/controllers/observ/traces_controller.rb

@@ -0,0 +1,86 @@
+module Observ
+  class TracesController < ApplicationController
+    def index
+      @traces = Observ::Trace
+        .includes(:observ_session)
+        .order(start_time: :desc)
+        .page(params[:page])
+        .per(Observ.config.pagination_per_page)
+
+      apply_filters if params[:filter].present?
+    end
+
+    def show
+      @trace = Observ::Trace.includes(:observations).find(params[:id])
+      @observations = @trace.observations.order(start_time: :asc)
+      @generations = @trace.generations
+      @spans = @trace.spans
+    end
+
+    def search
+      @traces = Observ::Trace
+        .includes(:observ_session)
+        .where("trace_id LIKE ? OR name LIKE ?", "%#{params[:q]}%", "%#{params[:q]}%")
+        .order(start_time: :desc)
+        .limit(50)
+
+      render :index
+    end
+
+    def annotations_drawer
+      @trace = Observ::Trace.find(params[:id])
+      @annotations = @trace.annotations.recent
+      @annotation = @trace.annotations.build
+    end
+
+    def text_output_drawer
+      @trace = Observ::Trace.includes(:observations, :annotations, observ_session: :annotations).find(params[:id])
+      @formatted_text = Observ::TraceTextFormatter.new(@trace).format
+    end
+
+    def add_to_dataset_drawer
+      @trace = Observ::Trace.find(params[:id])
+      @datasets = Observ::Dataset.order(:name)
+    end
+
+    def add_to_dataset
+      @trace = Observ::Trace.find(params[:id])
+      @dataset = Observ::Dataset.find(params[:dataset_id])
+
+      @item = @dataset.items.build(
+        input: @trace.input,
+        expected_output: params[:expected_output].presence || @trace.output,
+        source_trace: @trace,
+        status: :active
+      )
+
+      if @item.save
+        redirect_to dataset_path(@dataset, tab: "items"),
+          notice: "Trace added to dataset '#{@dataset.name}' successfully."
+      else
+        @datasets = Observ::Dataset.order(:name)
+        flash.now[:alert] = "Failed to add trace to dataset: #{@item.errors.full_messages.join(', ')}"
+        render :add_to_dataset_drawer, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def apply_filters
+      if params[:filter][:session_id].present?
+        session = Observ::Session.find_by(session_id: params[:filter][:session_id])
+        @traces = @traces.where(observ_session_id: session&.id) if session
+      end
+
+      @traces = @traces.where(name: params[:filter][:name]) if params[:filter][:name].present?
+
+      if params[:filter][:start_date].present?
+        @traces = @traces.where("start_time >= ?", params[:filter][:start_date])
+      end
+
+      if params[:filter][:end_date].present?
+        @traces = @traces.where("start_time <= ?", params[:filter][:end_date])
+      end
+    end
+  end
+end

data/app/forms/observ/prompt_form.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Observ
+  class PromptForm
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :name, :string
+    attribute :prompt, :string
+    attribute :config, :string  # JSON string from form
+    attribute :commit_message, :string
+    attribute :promote_to_production, :boolean, default: false
+    attribute :from_version, :integer
+
+    # For dependency injection
+    attr_accessor :created_by
+    attr_reader :persisted_prompt
+
+    validates :name, presence: true
+    validates :prompt, presence: true
+    validate :config_must_be_valid_json
+
+    def initialize(attributes = {})
+      super
+      load_from_version if from_version.present? && name.present?
+    end
+
+    def save
+      return false unless valid?
+
+      @persisted_prompt = PromptManager.create(
+        name: name,
+        prompt: prompt,
+        config: parsed_config,
+        commit_message: commit_message,
+        created_by: created_by,
+        promote_to_production: promote_to_production
+      )
+
+      true
+    rescue ActiveRecord::RecordInvalid => e
+      # Copy model errors to form
+      e.record.errors.each do |error|
+        errors.add(error.attribute, error.message)
+      end
+      false
+    end
+
+    def parsed_config
+      return {} if config.blank?
+      JSON.parse(config)
+    rescue JSON::ParserError
+      {}
+    end
+
+    # For form display - returns formatted JSON string
+    def config_json
+      return "" if config.blank?
+      config.is_a?(String) ? config : JSON.pretty_generate(config)
+    end
+
+    # ActiveModel compatibility for form_with
+    def model_name
+      ActiveModel::Name.new(self.class, nil, "observ_prompt_form")
+    end
+
+    def persisted?
+      false
+    end
+
+    def to_key
+      nil
+    end
+
+    def to_model
+      self
+    end
+
+    private
+
+    def config_must_be_valid_json
+      return if config.blank?
+      JSON.parse(config)
+    rescue JSON::ParserError => e
+      errors.add(:config, "must be valid JSON: #{e.message}")
+    end
+
+    def load_from_version
+      source = Prompt.find_by(name: name, version: from_version)
+      return unless source
+
+      self.prompt = source.prompt
+      self.config = source.config.present? ? JSON.pretty_generate(source.config) : ""
+    end
+  end
+end

data/app/helpers/observ/application_helper.rb

@@ -0,0 +1,9 @@
+module Observ
+  module ApplicationHelper
+    # Include helper modules to make them available across all views
+    include Observ::DashboardHelper
+    include Observ::ChatsHelper
+    include Observ::PaginationHelper
+    include Observ::DatasetsHelper
+  end
+end

data/app/helpers/observ/chats_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Observ
+  module ChatsHelper
+    # Returns formatted agent selection options for the chat form
+    #
+    # This helper provides agent selection options for use in select dropdowns.
+    # The options are memoized per request to avoid redundant agent discovery.
+    #
+    # Usage in views:
+    #   <%= form.select :agent_class_name, agent_select_options, {}, class: "observ-select" %>
+    #
+    # @return [Array<Array<String>>] options array for Rails select helper
+    #   Format: [["Display Name", "ClassName"], ...]
+    def agent_select_options
+      @agent_select_options ||= AgentSelectionService.options
+    end
+
+    # Returns a map of agent class names to their prompt names
+    #
+    # This helper identifies which agents use prompt management and maps them
+    # to their configured prompt names. Used by the chat form's Stimulus controller
+    # to dynamically show/hide the prompt version selector.
+    #
+    # Usage in views:
+    #   data: {
+    #     observ__chat_form_agents_with_prompts_value: agents_with_prompts_map.to_json
+    #   }
+    #
+    # @return [Hash<String, String>] Hash mapping agent class names to prompt names
+    #   Format: { "AgentClassName" => "prompt-name", ... }
+    def agents_with_prompts_map
+      @agents_with_prompts_map ||= begin
+        Observ::AgentProvider.all_agents.each_with_object({}) do |agent_class, hash|
+          # Check if agent includes PromptManagement and has prompt management enabled
+          if agent_class.included_modules.include?(Observ::PromptManagement) &&
+             agent_class.respond_to?(:prompt_management_enabled?) &&
+             agent_class.prompt_management_enabled?
+            # Extract prompt name from agent's configuration
+            prompt_name = agent_class.prompt_config[:prompt_name]
+            hash[agent_class.name] = prompt_name if prompt_name.present?
+          end
+        end
+      end
+    end
+  end
+end