aidp 0.7.0 → 0.8.1

data/lib/aidp/harness/ui/status_manager.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require "pastel"
+require_relative "base"
+require_relative "status_widget"
+require_relative "spinner_group"
+require_relative "frame_manager"
+
+module Aidp
+  module Harness
+    module UI
+      # Real-time status updates using CLI UI spinners
+      class StatusManager < Base
+        class StatusError < StandardError; end
+        class InvalidStatusError < StatusError; end
+        class UpdateError < StatusError; end
+
+        def initialize(ui_components = {})
+          super()
+          @status_widget = ui_components[:status_widget] || StatusWidget.new
+          @spinner_group = ui_components[:spinner_group] || SpinnerGroup.new
+          @frame_manager = ui_components[:frame_manager] || FrameManager.new
+          @formatter = ui_components[:formatter] || StatusManagerFormatter.new
+
+          @active_statuses = {}
+          @status_history = []
+        end
+
+        def show_workflow_status(workflow_name, &block)
+          validate_workflow_name(workflow_name)
+
+          @frame_manager.workflow_frame(workflow_name) do
+            @status_widget.show_loading_status("Starting #{workflow_name}") do |spinner|
+              track_workflow_status(workflow_name, spinner, &block)
+            end
+          end
+        rescue => e
+          raise UpdateError, "Failed to show workflow status: #{e.message}"
+        end
+
+        def show_step_status(step_name, &block)
+          validate_step_name(step_name)
+
+          @frame_manager.step_frame(step_name, 1, 1) do
+            @status_widget.show_loading_status("Processing #{step_name}") do |spinner|
+              track_step_status(step_name, spinner, &block)
+            end
+          end
+        rescue => e
+          raise UpdateError, "Failed to show step status: #{e.message}"
+        end
+
+        def show_concurrent_statuses(operations, &block)
+          validate_operations(operations)
+
+          @frame_manager.section("Concurrent Operations") do
+            @spinner_group.run_concurrent_operations(operations, &block)
+          end
+        rescue => e
+          raise UpdateError, "Failed to show concurrent statuses: #{e.message}"
+        end
+
+        def update_status(status_id, message, type = :info)
+          validate_status_id(status_id)
+          validate_message(message)
+          validate_status_type(type)
+
+          status = @active_statuses[status_id]
+          raise InvalidStatusError, "Status #{status_id} not found" unless status
+
+          update_status_display(status, message, type)
+          record_status_update(status_id, message, type)
+        end
+
+        def create_status_tracker(name, initial_message = "Initializing...")
+          validate_tracker_name(name)
+          validate_message(initial_message)
+
+          status_id = generate_status_id(name)
+          status_tracker = create_status_instance(name, initial_message)
+          @active_statuses[status_id] = status_tracker
+
+          record_status_creation(status_id, name, initial_message)
+          status_id
+        end
+
+        def complete_status(status_id, final_message = "Completed")
+          validate_status_id(status_id)
+
+          status = @active_statuses[status_id]
+          raise InvalidStatusError, "Status #{status_id} not found" unless status
+
+          complete_status_display(status, final_message)
+          @active_statuses.delete(status_id)
+
+          record_status_completion(status_id, final_message)
+        end
+
+        def show_success_status(message)
+          @status_widget.show_success_status(message)
+          record_status_event(:success, message)
+        end
+
+        def show_error_status(message)
+          @status_widget.show_error_status(message)
+          record_status_event(:error, message)
+        end
+
+        def show_warning_status(message)
+          @status_widget.show_warning_status(message)
+          record_status_event(:warning, message)
+        end
+
+        def show_info_status(message)
+          @status_widget.show_info_status(message)
+          record_status_event(:info, message)
+        end
+
+        def get_status_summary
+          {
+            active_statuses: @active_statuses.size,
+            completed_statuses: @status_history.count { |h| h[:status] == "completed" },
+            total_statuses: @status_history.size,
+            status_history: @status_history.dup
+          }
+        end
+
+        def clear_status_history
+          @status_history.clear
+        end
+
+        private
+
+        def validate_workflow_name(workflow_name)
+          raise InvalidStatusError, "Workflow name cannot be empty" if workflow_name.to_s.strip.empty?
+        end
+
+        def validate_step_name(step_name)
+          raise InvalidStatusError, "Step name cannot be empty" if step_name.to_s.strip.empty?
+        end
+
+        def validate_operations(operations)
+          raise InvalidStatusError, "Operations must be an array" unless operations.is_a?(Array)
+          raise InvalidStatusError, "Operations array cannot be empty" if operations.empty?
+        end
+
+        def validate_status_id(status_id)
+          raise InvalidStatusError, "Status ID cannot be empty" if status_id.to_s.strip.empty?
+        end
+
+        def validate_message(message)
+          raise InvalidStatusError, "Message cannot be empty" if message.to_s.strip.empty?
+        end
+
+        def validate_status_type(type)
+          valid_types = [:info, :success, :warning, :error, :loading]
+          unless valid_types.include?(type)
+            raise InvalidStatusError, "Invalid status type: #{type}. Must be one of: #{valid_types.join(", ")}"
+          end
+        end
+
+        def validate_tracker_name(name)
+          raise InvalidStatusError, "Tracker name cannot be empty" if name.to_s.strip.empty?
+        end
+
+        def track_workflow_status(workflow_name, spinner, &block) # Will be updated dynamically
+          yield(spinner) if block_given?
+          @status_widget.show_success_status("Completed #{workflow_name}")
+        rescue => e
+          @status_widget.show_error_status("Failed #{workflow_name}: #{e.message}")
+          raise
+        end
+
+        def track_step_status(step_name, spinner, &block)
+          yield(spinner) if block_given?
+          @status_widget.show_success_status("Completed #{step_name}")
+        rescue => e
+          @status_widget.show_error_status("Failed #{step_name}: #{e.message}")
+          raise
+        end
+
+        def update_status_display(status, message, type)
+          status[:message] = message
+          status[:type] = type
+          status[:last_updated] = Time.now
+
+          # Update the actual status display if it exists
+          if status[:spinner]
+            @status_widget.update_status(status[:spinner], message)
+          end
+        end
+
+        def complete_status_display(status, final_message)
+          status[:message] = final_message
+          status[:status] = "completed"
+          status[:completed_at] = Time.now
+
+          # Show final status
+          case status[:type]
+          when :success
+            @status_widget.show_success_status(final_message)
+          when :error
+            @status_widget.show_error_status(final_message)
+          when :warning
+            @status_widget.show_warning_status(final_message)
+          else
+            @status_widget.show_info_status(final_message)
+          end
+        end
+
+        def create_status_instance(name, initial_message)
+          {
+            name: name,
+            message: initial_message,
+            type: :info,
+            created_at: Time.now,
+            last_updated: Time.now,
+            status: "active"
+          }
+        end
+
+        def generate_status_id(name)
+          "#{name.downcase.gsub(/\s+/, "_")}_#{Time.now.to_i}"
+        end
+
+        def record_status_creation(status_id, name, initial_message)
+          @status_history << {
+            status_id: status_id,
+            name: name,
+            message: initial_message,
+            status: "created",
+            timestamp: Time.now
+          }
+        end
+
+        def record_status_update(status_id, message, type)
+          @status_history << {
+            status_id: status_id,
+            message: message,
+            type: type,
+            status: "updated",
+            timestamp: Time.now
+          }
+        end
+
+        def record_status_completion(status_id, final_message)
+          @status_history << {
+            status_id: status_id,
+            message: final_message,
+            status: "completed",
+            timestamp: Time.now
+          }
+        end
+
+        def record_status_event(type, message)
+          @status_history << {
+            type: type,
+            message: message,
+            status: "event",
+            timestamp: Time.now
+          }
+        end
+      end
+
+      # Formats status management display
+      class StatusManagerFormatter
+        def initialize
+          @pastel = Pastel.new
+        end
+
+        def format_workflow_status(workflow_name)
+          @pastel.bold(@pastel.blue("🔄 #{workflow_name} Workflow"))
+        end
+
+        def format_step_status(step_name)
+          @pastel.bold(@pastel.green("⚡ #{step_name}"))
+        end
+
+        def format_status_message(message, type)
+          case type
+          when :success
+            @pastel.green("✅ #{message}")
+          when :error
+            @pastel.red("❌ #{message}")
+          when :warning
+            @pastel.yellow("⚠️ #{message}")
+          when :info
+            @pastel.blue("ℹ️ #{message}")
+          when :loading
+            @pastel.dim("⏳ #{message}")
+          else
+            @pastel.dim(message)
+          end
+        end
+
+        def format_status_summary(summary)
+          result = []
+          result << @pastel.bold(@pastel.blue("📊 Status Summary"))
+          result << "Active statuses: #{@pastel.bold(summary[:active_statuses])}"
+          result << "Completed statuses: #{@pastel.bold(summary[:completed_statuses])}"
+          result << "Total statuses: #{@pastel.bold(summary[:total_statuses])}"
+          result.join("\n")
+        end
+
+        def format_status_tracker(tracker)
+          status_emoji = (tracker[:status] == "completed") ? "✅" : "🔄"
+          "#{status_emoji} #{@pastel.bold(tracker[:name])} - #{@pastel.dim(tracker[:message])}"
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/ui/status_widget.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+require "pastel"
+require_relative "base"
+
+module Aidp
+  module Harness
+    module UI
+      # Handles status display using CLI UI spinners
+      class StatusWidget < Base
+        class StatusError < StandardError; end
+        class InvalidStatusError < StatusError; end
+        class DisplayError < StatusError; end
+
+        def initialize(ui_components = {})
+          super()
+          @spinner = ui_components[:spinner] || TTY::Spinner
+          @pastel = Pastel.new
+          @formatter = ui_components[:formatter] || StatusFormatter.new
+          @status_history = []
+          @current_spinner = nil
+          @spinner_active = false
+        end
+
+        def show_status(message, &block)
+          validate_message(message)
+
+          formatted_message = @formatter.format_status_message(message)
+          @spinner.spin(formatted_message) do |spinner|
+            yield(spinner) if block_given?
+          end
+        rescue => e
+          raise DisplayError, "Failed to show status: #{e.message}"
+        end
+
+        def update_status(spinner, message)
+          validate_spinner_and_message(spinner, message)
+
+          formatted_message = @formatter.format_status_message(message)
+          spinner.update_title(formatted_message)
+        rescue => e
+          raise DisplayError, "Failed to update status: #{e.message}"
+        end
+
+        def show_loading_status(operation_name, &block)
+          validate_operation_name(operation_name)
+
+          message = @formatter.format_loading_message(operation_name)
+          show_status(message, &block)
+        rescue => e
+          raise DisplayError, "Failed to show loading status: #{e.message}"
+        end
+
+        def show_success_status(message)
+          validate_message(message)
+
+          formatted_message = @formatter.format_success_message(message)
+          puts(formatted_message)
+        rescue => e
+          raise DisplayError, "Failed to show success status: #{e.message}"
+        end
+
+        def show_error_status(message)
+          validate_message(message)
+
+          formatted_message = @formatter.format_error_message(message)
+          puts(formatted_message)
+        rescue => e
+          raise DisplayError, "Failed to show error status: #{e.message}"
+        end
+
+        def show_warning_status(message)
+          validate_message(message)
+
+          formatted_message = @formatter.format_warning_message(message)
+          puts(formatted_message)
+        rescue => e
+          raise DisplayError, "Failed to show warning status: #{e.message}"
+        end
+
+        # Methods expected by tests
+        def display_status(status_type, message, error_data = nil)
+          validate_status_type(status_type)
+          validate_message(message)
+
+          case status_type
+          when :loading
+            display_loading_status(message)
+          when :success
+            display_success_status(message)
+          when :error
+            display_error_status(message, error_data)
+          when :warning
+            display_warning_status(message)
+          end
+
+          record_status_history(status_type, message, error_data)
+        rescue InvalidStatusError => e
+          raise e
+        rescue => e
+          raise DisplayError, "Failed to display status: #{e.message}"
+        end
+
+        def start_spinner(message)
+          validate_message(message)
+          stop_spinner if @spinner_active
+
+          @spinner_active = true
+          @current_spinner = @spinner.new("⏳ #{message} :spinner", format: :pulse)
+          @current_spinner.start
+        end
+
+        def stop_spinner
+          return unless @spinner_active
+
+          @current_spinner&.stop
+          @spinner_active = false
+          @current_spinner = nil
+        end
+
+        def update_spinner_message(message)
+          validate_message(message)
+          raise DisplayError, "No active spinner to update" unless @spinner_active
+
+          @current_spinner&.stop
+          @current_spinner = @spinner.new("⏳ #{message} :spinner", format: :pulse)
+          @current_spinner.start
+        end
+
+        def display_status_with_duration(status_type, message, duration)
+          validate_status_type(status_type)
+          validate_message(message)
+
+          formatted_duration = format_duration(duration)
+          message_with_duration = "#{message} (#{formatted_duration})"
+          display_status(status_type, message_with_duration)
+        end
+
+        def display_multiple_status(status_items)
+          return if status_items.empty?
+
+          status_items.each do |item|
+            display_status(item[:type], item[:message], item[:error_data])
+          end
+        end
+
+        def get_status_history
+          @status_history.dup
+        end
+
+        def clear_status_history
+          @status_history.clear
+        end
+
+        def format_duration(seconds)
+          return "0s" if seconds <= 0
+
+          if seconds < 60
+            "#{seconds.round(1)}s"
+          elsif seconds < 3600
+            minutes = (seconds / 60).floor
+            remaining_seconds = (seconds % 60).floor
+            "#{minutes}m #{remaining_seconds}s"
+          else
+            hours = (seconds / 3600).floor
+            minutes = ((seconds % 3600) / 60).floor
+            remaining_seconds = (seconds % 60).floor
+            "#{hours}h #{minutes}m #{remaining_seconds}s"
+          end
+        end
+
+        def spinner_active?
+          @spinner_active
+        end
+
+        def current_spinner_message
+          return nil unless @spinner_active
+          @current_spinner&.message&.to_s&.gsub(/⏳\s+|\s+:spinner/, "")
+        end
+
+        private
+
+        def validate_message(message)
+          raise InvalidStatusError, "Message cannot be empty" if message.to_s.strip.empty?
+        end
+
+        def validate_spinner_and_message(spinner, message)
+          raise InvalidStatusError, "Spinner cannot be nil" if spinner.nil?
+          validate_message(message)
+        end
+
+        def validate_operation_name(operation_name)
+          raise InvalidStatusError, "Operation name cannot be empty" if operation_name.to_s.strip.empty?
+        end
+
+        def validate_status_type(status_type)
+          valid_types = [:loading, :success, :error, :warning]
+          unless valid_types.include?(status_type)
+            raise InvalidStatusError, "Invalid status type: #{status_type}. Must be one of: #{valid_types.join(", ")}"
+          end
+        end
+
+        def record_status_history(status_type, message, error_data)
+          @status_history << {
+            type: status_type,
+            message: message,
+            error_data: error_data,
+            timestamp: Time.now
+          }
+        end
+
+        def display_loading_status(message)
+          puts("⏳ #{message}")
+        end
+
+        def display_success_status(message)
+          puts("✅ #{message}")
+        end
+
+        def display_error_status(message, error_data)
+          puts("❌ #{message}")
+          if error_data && error_data[:message]
+            puts("  #{error_data[:message]}")
+          end
+        end
+
+        def display_warning_status(message)
+          puts("⚠️ #{message}")
+        end
+      end
+
+      # Formats status display messages
+      class StatusFormatter
+        def initialize
+          @pastel = Pastel.new
+        end
+
+        def format_status_message(message)
+          "⏳ #{message}"
+        end
+
+        def format_loading_message(operation_name)
+          "Loading #{operation_name}..."
+        end
+
+        def format_success_message(message)
+          "#{@pastel.green("✓")} #{message}"
+        end
+
+        def format_error_message(message)
+          "#{@pastel.red("✗")} #{message}"
+        end
+
+        def format_warning_message(message)
+          "#{@pastel.yellow("⚠")} #{message}"
+        end
+
+        def format_info_message(message)
+          "#{@pastel.blue("ℹ")} #{message}"
+        end
+
+        def format_step_message(step_name, status)
+          case status
+          when :starting
+            "Starting #{step_name}..."
+          when :in_progress
+            "Processing #{step_name}..."
+          when :completed
+            "Completed #{step_name}"
+          when :failed
+            "Failed #{step_name}"
+          else
+            "#{step_name}: #{status}"
+          end
+        end
+      end
+    end
+  end
+end