meta_workflows 0.7.0

data/app/assets/stylesheets/meta_workflows/application.css

@@ -0,0 +1,161 @@
+/* AI Generated Content */
+.meta-workflows.chat {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+    color: var(--slate-800);
+    font-size: 1.125rem;
+    line-height: 1.75;
+  
+    h1 {
+      color: var(--slate-800);
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+      font-size: 1.875rem;
+      line-height: 1.25;
+    }
+  
+    h2 {
+      color: var(--slate-800);
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+      font-size: 1.5rem;
+      line-height: 1.25;
+    }
+  
+    h3 {
+      color: var(--slate-800);
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+      font-size: 1.25rem;
+      line-height: 1.25;
+    }
+  
+    h4 {
+      color: var(--slate-800);
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+      font-size: 1.125rem;
+      line-height: 1.25;
+    }
+  
+    h5 {
+      color: var(--slate-800);
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+      font-size: 1rem;
+      line-height: 1.25;
+    }
+  
+    h6 {
+      color: var(--slate-800);
+      font-weight: 600;
+      margin-bottom: 0.5rem;
+      font-size: 0.875rem;
+      line-height: 1.25;
+    }
+  
+    /* Combined list styles */
+    ul,
+    ol {
+      display: flex;
+      flex-direction: column;
+      gap: .5rem;
+      padding-left: 0;
+      list-style-type: none;
+  
+      li {
+        display: flex;
+        padding: 1rem 1.375rem;
+        border: 1px solid var(--slate-300);
+        border-radius: 0.875rem;
+        background-color: white;
+        font-size: 1.25rem;
+        font-weight: 600;
+        line-height: 1.375;
+  
+        &::before {
+          display: none;
+        }
+      }
+    }
+  
+    /* Ordered list specific styles */
+    ol {
+      counter-reset: list-counter;
+  
+      li::before {
+        content: counter(list-counter) ".";
+        counter-increment: list-counter;
+        display: inline-block;
+        width: 1.5em;
+        margin-right: 0.5em;
+        color: var(--slate-400);
+      }
+    }
+  
+    a {
+      color: #2563eb;
+      text-decoration: underline;
+  
+      &:hover {
+        color: #1d4ed8;
+      }
+    }
+  
+    pre {
+      background-color: #f9fafb;
+      padding: 1rem;
+      border-radius: 0.5rem;
+      overflow-x: auto;
+      margin: 1rem 0;
+    }
+  
+    code {
+      background-color: #f9fafb;
+      padding: 0.125rem 0.375rem;
+      border-radius: 0.25rem;
+      font-size: 0.875rem;
+      font-family: ui-monospace, monospace;
+    }
+  
+    blockquote {
+      border-left: 4px solid #e5e7eb;
+      padding-left: 1rem;
+      font-style: italic;
+      color: #374151;
+      margin: 1rem 0;
+    }
+  
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 1rem 0;
+    }
+  
+    th,
+    td {
+      border: 1px solid #e5e7eb;
+      padding: 0.5rem;
+      text-align: left;
+    }
+  
+    th {
+      background-color: #f9fafb;
+      font-weight: 600;
+    }
+  
+    img {
+      border-radius: 0.5rem;
+      margin: 1rem 0;
+    }
+  
+    strong {
+      font-weight: 600;
+      color: var(--slate-800);
+    }
+  
+    em {
+      font-style: italic;
+    }
+  }

data/app/controllers/meta_workflows/application_controller.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    # Add any MetaWorkflows-specific controller functionality here
+    # This ensures proper engine isolation
+  end
+end

data/app/controllers/meta_workflows/debug_controller.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class DebugController < MetaWorkflows::ApplicationController
+    include MetaWorkflows::DebugHelper
+
+    layout 'meta_workflows/debug'
+
+    # Apply authentication only in production environment
+    before_action :authenticate_with_basic_auth, if: :production_environment?
+
+    # Skip CSRF protection for this debug interface
+    skip_before_action :verify_authenticity_token
+
+    def index
+      redirect_to workflows_path
+    end
+
+    def workflows
+      @workflows = MetaWorkflows::Workflow.includes(:workflow_executions)
+                                          .order(created_at: :desc)
+
+      # Simple search functionality - search by name only
+      @workflows = @workflows.where('name ILIKE ?', "%#{params[:search]}%") if params[:search].present?
+
+      # Apply pagination if available
+      @workflows = paginate_collection(@workflows)
+    end
+
+    def show_workflow
+      @workflow = MetaWorkflows::Workflow.find(params[:id])
+      @executions = @workflow.workflow_executions
+                             .includes(workflow_steps: :chat)
+                             .order(created_at: :desc)
+
+      @executions = paginate_collection(@executions)
+    end
+
+    def executions
+      @executions = MetaWorkflows::WorkflowExecution.includes(:workflow, workflow_steps: :chat)
+                                                    .order(created_at: :desc)
+
+      @executions = MetaWorkflows::ExecutionFilterService.new(@executions, params).apply_filters
+
+      # Apply pagination
+      @executions = paginate_collection(@executions)
+    end
+
+    def show_execution
+      @execution = MetaWorkflows::WorkflowExecution.includes(
+        :workflow,
+        workflow_steps: { chat: { messages: :tool_calls } }
+      ).find(params[:id])
+    end
+
+    def export_execution
+      @execution = MetaWorkflows::WorkflowExecution.includes(
+        :workflow,
+        workflow_steps: { chat: { messages: :tool_calls } }
+      ).find(params[:id])
+
+      export_data = MetaWorkflows::ExportExecutionService.new(@execution).export_data
+
+      respond_to do |format|
+        format.json { render json: export_data }
+        format.html { redirect_to execution_path(@execution), alert: t('meta_workflows.export_only_json') }
+      end
+    end
+
+    protected
+
+    def authenticate_with_basic_auth
+      return unless production_environment?
+      return unless authentication_required?
+
+      authenticate_or_request_with_http_basic do |username, password|
+        username == ENV.fetch('SIDEKIQ_USER', nil) &&
+          password == ENV.fetch('SIDEKIQ_PASSWORD', nil)
+      end
+    end
+
+    private
+
+    def production_environment?
+      Rails.env.production?
+    end
+
+    def authentication_required?
+      ENV['SIDEKIQ_USER'].present? && ENV['SIDEKIQ_PASSWORD'].present?
+    end
+
+    def paginate_collection(collection)
+      # Use Kaminari if available, otherwise limit to 25 records
+      if defined?(Kaminari) && collection.respond_to?(:page)
+        collection.page(params[:page]).per(25)
+      else
+        collection.limit(25).offset(((params[:page]&.to_i || 1) - 1) * 25)
+      end
+    end
+  end
+end

data/app/controllers/meta_workflows/humans_controller.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class HumansController < MetaController
+    include MetaWorkflows::MetaWorkflowsHelper
+    before_action :set_workflow_data, only: [:update]
+
+    def update
+      if params[:advance].present?
+        advance_workflow
+        render_loader_stream
+      else
+        process_human_input
+        render_response_form_stream
+      end
+    end
+
+    private
+
+    def render_loader_stream
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: [
+            turbo_stream.replace(
+              target_frame_id(@record),
+              partial: meta_loader,
+              locals: {
+                record: @record,
+                step_progress: fetch_step_progress
+              }
+            ),
+            turbo_stream.replace(
+              target_frame_id(@record, form: true),
+              partial: meta_response_form,
+              locals: response_form_locals(response_enabled: false)
+            )
+          ]
+        end
+      end
+    end
+
+    def render_response_form_stream
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.replace(
+            target_frame_id(@record, form: true),
+            partial: meta_response_form,
+            locals: response_form_locals(response_enabled: true, responding: true)
+          )
+        end
+      end
+    end
+
+    def advance_workflow
+      dialogue = collect_messages_from_chat
+      @workflow_execution.increment_step
+
+      MetaWorkflows::MetaWorkflowJob.perform_later(
+        record_id: @record.id,
+        record_type: @record.class.name,
+        workflow_name: nil,
+        user_id: current_user.id,
+        inputs: { dialogue: dialogue }
+      )
+    end
+
+    def process_human_input
+      MetaWorkflows::HumanInputJob.perform_later(
+        user_id: current_user.id,
+        record: @record,
+        params: {
+          inputs: params[:message],
+          chat_id: params[:chat_id],
+          prompt_id: @prompt_id
+        }
+      )
+    end
+
+    def collect_messages_from_chat
+      messages = MetaWorkflows::Chat.find(params[:chat_id]).messages
+      messages.map do |m|
+        { role: m.role, content: m.content.strip }
+      end
+    end
+
+    def response_form_locals(response_enabled: true, responding: false)
+      {
+        record: @record,
+        workflow_execution_id: @workflow_execution.id,
+        chat_id: params[:chat_id],
+        response_enabled: response_enabled,
+        responding: responding
+      }
+    end
+  end
+end

data/app/controllers/meta_workflows/meta_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class MetaController < MetaWorkflows::ApplicationController
+    include MetaWorkflows::MetaWorkflowsHelper
+
+    def set_workflow_data
+      @workflow_execution = MetaWorkflows::WorkflowExecution.find(params[:id])
+      @record = @workflow_execution.record
+      @workflow = @workflow_execution.workflow
+      @prompt_id = @workflow.prompt_id(@workflow_execution.current_step)
+    end
+
+    protected
+
+    def fetch_step_progress
+      @workflow.step_progress(@workflow_execution.current_step) || ['Processing your request...',
+                                                                    'Talking to the LLM...']
+    end
+  end
+end

data/app/helpers/meta_workflows/application_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module ApplicationHelper
+    include MetaWorkflows::MetaWorkflowsHelper
+  end
+end

data/app/helpers/meta_workflows/debug_helper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module DebugHelper
+    include StatusBadgeHelper
+    include ExecutionHelper
+    include FormattingHelper
+
+    # Helper for truncating long text with tooltip
+    def truncate_with_tooltip(text, length: 50)
+      return '' if text.blank?
+
+      if text.length > length
+        content_tag :span, truncate(text, length: length), title: text, class: 'cursor-help'
+      else
+        text
+      end
+    end
+
+    # Helper for relative time with absolute time tooltip
+    def time_with_tooltip(time)
+      return 'N/A' if time.blank?
+
+      content_tag :span, "#{time_ago_in_words(time)} ago",
+                  title: time.strftime('%Y-%m-%d %H:%M:%S %Z'),
+                  class: 'cursor-help'
+    end
+
+    # Helper to safely get step data from workflow
+    def safe_step_data(workflow, step_number)
+      workflow.step_data(step_number)
+    rescue StandardError => e
+      { 'error' => e.message }
+    end
+
+    # Helper to safely get workflow name by ID
+    def safe_workflow_name(workflow_id)
+      MetaWorkflows::Workflow.find(workflow_id).name
+    rescue ActiveRecord::RecordNotFound
+      "Workflow ##{workflow_id}"
+    rescue StandardError
+      'Unknown Workflow'
+    end
+
+    # Helper to safely display user information
+    def user_display_name(user)
+      return 'Unknown User' if user.blank?
+
+      user.try(:name) || user.try(:email) || "User ##{user.id}"
+    rescue StandardError
+      'Unknown User'
+    end
+  end
+end

data/app/helpers/meta_workflows/execution_helper.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module ExecutionHelper
+    # Helper to calculate execution progress percentage
+    def execution_progress_percentage(execution)
+      return 0 if execution.workflow.total_steps.zero?
+
+      ((execution.current_step.to_f / execution.workflow.total_steps) * 100).round(1)
+    rescue StandardError
+      0
+    end
+
+    # Helper to format execution progress display
+    def execution_progress_display(execution)
+      total_steps = execution.workflow.total_steps
+      current_step = execution.current_step
+      percentage = execution_progress_percentage(execution)
+
+      content_tag :div do
+        concat content_tag(:div, "#{current_step} / #{total_steps}", class: 'text-sm text-gray-900')
+        concat content_tag(:div, "#{percentage}% complete", class: 'text-xs text-gray-500')
+      end
+    rescue StandardError
+      content_tag :span, 'N/A', class: 'text-sm text-gray-500'
+    end
+
+    # Helper to display record info
+    def record_info_display(execution)
+      content_tag :div do
+        concat content_tag(:div, execution.record_type, class: 'font-medium')
+        concat content_tag(:div, "##{execution.record_id}", class: 'text-xs text-gray-500')
+      end
+    end
+
+    # Helper to determine execution status with better logic including errors
+    def execution_status(execution)
+      return 'completed' if execution.completed?
+      return 'error' if execution.workflow_steps.with_errors.any?
+      return 'failed' if execution.updated_at < 1.hour.ago
+
+      'running'
+    end
+
+    # Helper to get error count for execution
+    def execution_error_count(execution)
+      execution.workflow_steps.with_errors.count
+    end
+
+    # Helper to display execution status with error awareness
+    def execution_status_display(execution)
+      status = execution_status(execution)
+      error_count = execution_error_count(execution)
+
+      case status
+      when 'completed'
+        if error_count.positive?
+          content_tag :div do
+            concat status_badge('completed')
+            concat content_tag(:span, " (#{error_count} error#{'s' if error_count > 1})",
+                               class: 'text-xs text-red-600 ml-1')
+          end
+        else
+          status_badge('completed')
+        end
+      when 'error'
+        content_tag :div do
+          concat status_badge('error')
+          concat content_tag(:span, " (#{error_count} error#{'s' if error_count > 1})",
+                             class: 'text-xs text-red-600 ml-1')
+        end
+      else
+        status_badge(status)
+      end
+    end
+  end
+end

data/app/helpers/meta_workflows/formatting_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module FormattingHelper
+    # Format JSON data for readable display
+    def pretty_json(data)
+      return 'No data' if data.blank?
+
+      begin
+        formatted = data.is_a?(String) ? JSON.parse(data) : data
+        JSON.pretty_generate(formatted)
+      rescue JSON::ParserError
+        data.to_s
+      end
+    end
+
+    # Generate a formatted JSON display with syntax highlighting
+    def json_display(data, classes: 'bg-gray-100 p-4 rounded-lg text-sm overflow-x-auto')
+      content_tag :pre, pretty_json(data), class: classes
+    end
+
+    # Helper to format token usage
+    def format_token_usage(input_tokens, output_tokens)
+      tokens = [input_tokens, output_tokens].compact
+      return '' if tokens.empty?
+
+      "Tokens: #{tokens.join('/')}"
+    end
+  end
+end

data/app/helpers/meta_workflows/meta_workflows_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module MetaWorkflowsHelper
+    def target_frame_id(record, form: nil)
+      base_id = "#{record.class.name.downcase}_#{record.id}"
+      form ? "#{base_id}_form" : base_id
+    end
+
+    def turbo_stream_name(record)
+      [record.class.name.downcase, record.id]
+    end
+
+    def meta_loader
+      'meta_workflows/loader'
+    end
+
+    def meta_response_form
+      'meta_workflows/response_form'
+    end
+
+    def meta_response
+      'meta_workflows/response'
+    end
+
+    def meta_redirect
+      'meta_workflows/redirect'
+    end
+
+    def random_chat_placeholder
+      [
+        'What would you like to improve?',
+        'Suggest an edit or ask for changes...',
+        'Let me know how I can improve this.',
+        'Not quite right? Let me know.',
+        'Edit, clarify, or request a change.',
+        'Happy with this, or want changes?'
+      ].sample
+    end
+  end
+end

data/app/helpers/meta_workflows/status_badge_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module StatusBadgeHelper
+    # Helper for status badges
+    def status_badge(status)
+      case status&.to_s&.downcase
+      when 'completed', 'success'
+        content_tag :span, status.capitalize,
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-green-100 text-green-800'
+      when 'running', 'in_progress', 'processing'
+        content_tag :span, status.capitalize,
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-blue-100 text-blue-800'
+      when 'failed', 'error'
+        content_tag :span, status.capitalize,
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-red-100 text-red-800'
+      when 'pending', 'waiting'
+        content_tag :span, status.capitalize,
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-yellow-100 text-yellow-800'
+      else
+        content_tag :span, status.to_s.capitalize,
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-gray-100 text-gray-800'
+      end
+    end
+
+    # Helper to display workflow step status
+    def workflow_step_status(workflow_step, current_step)
+      if workflow_step.error?
+        content_tag :span, 'Error',
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-red-100 text-red-800'
+      elsif workflow_step.step == current_step
+        content_tag :span, 'Current',
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-blue-100 text-blue-800'
+      elsif workflow_step.step < current_step
+        content_tag :span, 'Completed',
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-green-100 text-green-800'
+      else
+        content_tag :span, 'Pending',
+                    class: 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ' \
+                           'bg-gray-100 text-gray-800'
+      end
+    end
+
+    # Helper to format message role with proper styling
+    def message_role_badge(role)
+      case role&.downcase
+      when 'user'
+        'bg-blue-50 border-blue-200'
+      when 'assistant'
+        'bg-green-50 border-green-200'
+      when 'system'
+        'bg-purple-50 border-purple-200'
+      else
+        'bg-gray-50 border-gray-200'
+      end
+    end
+  end
+end

data/app/jobs/meta_workflows/application_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class ApplicationJob < ActiveJob::Base
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+
+    # Add any MetaWorkflows-specific job functionality here
+    # This ensures proper engine isolation
+  end
+end