aidp 0.7.0 → 0.8.1

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require_relative "base"
+
+module Aidp
+  module Harness
+    module UI
+      # Handles interactive question collection using CLI UI prompts
+      class QuestionCollector < Base
+        class QuestionError < StandardError; end
+        class ValidationError < QuestionError; end
+        class CollectionError < QuestionError; end
+
+        def initialize(ui_components = {})
+          super()
+          @prompt = ui_components[:prompt] || TTY::Prompt.new
+          @validator = ui_components[:validator] || QuestionValidator.new
+        end
+
+        def collect_questions(questions)
+          validate_questions_input(questions)
+
+          # Validate all questions first
+          errors = get_validation_errors(questions)
+          raise ValidationError, errors.join("\n") unless errors.empty?
+
+          responses = {}
+          questions.each_with_index do |question, index|
+            question_key = question[:key] || "question_#{index + 1}"
+            responses[question_key] = collect_single_question(question, index + 1)
+          end
+          responses
+        rescue ValidationError => e
+          raise e
+        rescue => e
+          raise CollectionError, "Failed to collect questions: #{e.message}"
+        end
+
+        def collect_single_question(question, number)
+          validate_question_format(question)
+
+          question_text = format_question_text(question, number)
+          response = prompt_for_response(question_text, question)
+
+          validate_response(response, question)
+          response
+        rescue => e
+          raise QuestionError, "Failed to collect question #{number}: #{e.message}"
+        end
+
+        def validate_questions(questions)
+          return true if questions.empty?
+
+          questions.all? do |question|
+            validate_question_format(question)
+            true
+          rescue ValidationError
+            false
+          end
+        end
+
+        def get_validation_errors(questions)
+          errors = []
+
+          questions.each_with_index do |question, index|
+            validate_question_format(question)
+          rescue ValidationError => e
+            errors << "Question #{index + 1}: #{e.message}"
+          end
+
+          errors
+        end
+
+        def validate_question_format(question)
+          raise ValidationError, "Question must be a hash" unless question.is_a?(Hash)
+          raise ValidationError, "Question must have :text key" unless question.key?(:text)
+          raise ValidationError, "Question text cannot be empty" if question[:text].to_s.strip.empty?
+          unless question.key?(:type) && question.key?(:required)
+            raise ValidationError, "Question missing required fields"
+          end
+        end
+
+        def validate_questions_input(questions)
+          raise ValidationError, "Questions must be an array" unless questions.is_a?(Array)
+          # Allow empty array - return empty hash
+        end
+
+        private
+
+        def validate_response(response, question)
+          @validator.validate(response, question)
+        end
+
+        def format_question_text(question, number)
+          "Question #{number}: #{question[:text]}"
+        end
+
+        def prompt_for_response(question_text, question)
+          @prompt.ask(question_text) do |handler|
+            add_question_options(handler, question)
+          end
+        end
+
+        def add_question_options(handler, question)
+          return unless question[:options]
+
+          question[:options].each { |option| handler.option(option) }
+        end
+      end
+
+      # Validates question responses
+      class QuestionValidator
+        def validate(response, question)
+          validate_required(response, question)
+          validate_format(response, question)
+          validate_options(response, question)
+        end
+
+        private
+
+        def validate_required(response, question)
+          return unless question[:required]
+          raise ValidationError, "Response is required" if response.nil? || response.to_s.strip.empty?
+        end
+
+        def validate_format(response, question)
+          return unless question[:format]
+          return if response.to_s.match?(question[:format])
+          raise ValidationError, "Response format is invalid"
+        end
+
+        def validate_options(response, question)
+          return unless question[:options]
+          return if question[:options].include?(response)
+          raise ValidationError, "Response must be one of: #{question[:options].join(", ")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+require_relative "base"
+
+module Aidp
+  module Harness
+    module UI
+      # Handles concurrent operations using CLI UI spinner groups
+      class SpinnerGroup < Base
+        class SpinnerGroupError < StandardError; end
+        class InvalidOperationError < SpinnerGroupError; end
+        class ExecutionError < SpinnerGroupError; end
+
+        def initialize(ui_components = {})
+          super()
+          @spinner_class = ui_components[:spinner_class] || TTY::Spinner
+          @formatter = ui_components[:formatter] || SpinnerGroupFormatter.new
+          @spinners = {}
+        end
+
+        def run_concurrent_operations(operations)
+          validate_operations(operations)
+
+          # Create individual spinners for each operation
+          operations.each do |operation|
+            spinner = @spinner_class.new(
+              "#{operation[:name]}...",
+              format: :dots,
+              success_mark: "✓",
+              error_mark: "✗"
+            )
+            @spinners[operation[:id]] = spinner
+            spinner.start
+          end
+
+          # Execute operations
+          operations.each do |operation|
+            operation[:block].call
+            @spinners[operation[:id]].success(operation[:name])
+          rescue => e
+            @spinners[operation[:id]].error(operation[:name])
+            raise e
+          end
+        rescue => e
+          raise ExecutionError, "Failed to run concurrent operations: #{e.message}"
+        end
+
+        def run_workflow_steps(steps)
+          validate_steps(steps)
+
+          operations = convert_steps_to_operations(steps)
+          run_concurrent_operations(operations)
+        rescue => e
+          raise ExecutionError, "Failed to run workflow steps: #{e.message}"
+        end
+
+        def run_analysis_tasks(tasks)
+          validate_tasks(tasks)
+
+          operations = convert_tasks_to_operations(tasks)
+          run_concurrent_operations(operations)
+        rescue => e
+          raise ExecutionError, "Failed to run analysis tasks: #{e.message}"
+        end
+
+        def run_provider_operations(provider_operations)
+          validate_provider_operations(provider_operations)
+
+          operations = convert_provider_operations(provider_operations)
+          run_concurrent_operations(operations)
+        rescue => e
+          raise ExecutionError, "Failed to run provider operations: #{e.message}"
+        end
+
+        private
+
+        def validate_operations(operations)
+          raise InvalidOperationError, "Operations must be an array" unless operations.is_a?(Array)
+          raise InvalidOperationError, "Operations array cannot be empty" if operations.empty?
+
+          operations.each_with_index do |operation, index|
+            validate_operation(operation, index)
+          end
+        end
+
+        def validate_operation(operation, index)
+          raise InvalidOperationError, "Operation #{index} must be a hash" unless operation.is_a?(Hash)
+          raise InvalidOperationError, "Operation #{index} must have :title" unless operation.key?(:title)
+          raise InvalidOperationError, "Operation #{index} must have :block" unless operation.key?(:block)
+          raise InvalidOperationError, "Operation #{index} title cannot be empty" if operation[:title].to_s.strip.empty?
+          raise InvalidOperationError, "Operation #{index} block must be callable" unless operation[:block].respond_to?(:call)
+        end
+
+        def validate_steps(steps)
+          raise InvalidOperationError, "Steps must be an array" unless steps.is_a?(Array)
+          raise InvalidOperationError, "Steps array cannot be empty" if steps.empty?
+        end
+
+        def validate_tasks(tasks)
+          raise InvalidOperationError, "Tasks must be an array" unless tasks.is_a?(Array)
+          raise InvalidOperationError, "Tasks array cannot be empty" if tasks.empty?
+        end
+
+        def validate_provider_operations(provider_operations)
+          raise InvalidOperationError, "Provider operations must be an array" unless provider_operations.is_a?(Array)
+          raise InvalidOperationError, "Provider operations array cannot be empty" if provider_operations.empty?
+        end
+
+        def add_operation(spin_group, operation)
+          formatted_title = @formatter.format_operation_title(operation[:title])
+          spin_group.add(formatted_title) do |spinner|
+            execute_operation_with_error_handling(operation, spinner)
+          end
+        end
+
+        def execute_operation_with_error_handling(operation, spinner)
+          operation[:block].call(spinner)
+        rescue => e
+          spinner.update_title(@formatter.format_error_title(operation[:title], e.message))
+          raise
+        end
+
+        def convert_steps_to_operations(steps)
+          steps.map do |step|
+            {
+              title: @formatter.format_step_title(step[:name]),
+              block: step[:block]
+            }
+          end
+        end
+
+        def convert_tasks_to_operations(tasks)
+          tasks.map do |task|
+            {
+              title: @formatter.format_task_title(task[:name]),
+              block: task[:block]
+            }
+          end
+        end
+
+        def convert_provider_operations(provider_operations)
+          provider_operations.map do |op|
+            {
+              title: @formatter.format_provider_title(op[:provider], op[:operation]),
+              block: op[:block]
+            }
+          end
+        end
+      end
+
+      # Formats spinner group display text
+      class SpinnerGroupFormatter
+        def format_operation_title(title)
+          "🔄 #{title}"
+        end
+
+        def format_step_title(step_name)
+          "⚡ #{step_name}"
+        end
+
+        def format_task_title(task_name)
+          "📋 #{task_name}"
+        end
+
+        def format_provider_title(provider_name, operation)
+          "🤖 #{provider_name}: #{operation}"
+        end
+
+        def format_error_title(original_title, error_message)
+          "❌ #{original_title} (Error: #{error_message})"
+        end
+
+        def format_success_title(original_title)
+          "✅ #{original_title}"
+        end
+
+        def format_progress_title(title, current, total)
+          "📊 #{title} (#{current}/#{total})"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "tty-spinner"
+require "pastel"
+
+module Aidp
+  module Harness
+    module UI
+      # Unified spinner helper that automatically manages TTY::Spinner lifecycle
+      # Usage: with_spinner("Loading...") { some_operation }
+      class SpinnerHelper
+        class SpinnerError < StandardError; end
+
+        def initialize
+          @pastel = Pastel.new
+          @active_spinners = []
+        end
+
+        # Main method: automatically manages spinner around a block
+        def with_spinner(message, format: :dots, success_message: nil, error_message: nil, &block)
+          raise ArgumentError, "Block required for with_spinner" unless block_given?
+
+          spinner = create_spinner(message, format)
+          start_spinner(spinner)
+
+          begin
+            result = yield(spinner)
+            success_spinner(spinner, success_message || message)
+            result
+          rescue => e
+            error_spinner(spinner, error_message || "Failed: #{e.message}")
+            raise e
+          ensure
+            cleanup_spinner(spinner)
+          end
+        end
+
+        # Convenience methods for common patterns
+        def with_loading_spinner(message, &block)
+          with_spinner("⏳ #{message}", format: :dots, &block)
+        end
+
+        def with_processing_spinner(message, &block)
+          with_spinner("🔄 #{message}", format: :pulse, &block)
+        end
+
+        def with_saving_spinner(message, &block)
+          with_spinner("💾 #{message}", format: :dots, &block)
+        end
+
+        def with_analyzing_spinner(message, &block)
+          with_spinner("🔍 #{message}", format: :dots, &block)
+        end
+
+        def with_building_spinner(message, &block)
+          with_spinner("🏗️ #{message}", format: :dots, &block)
+        end
+
+        # For operations that might take a while
+        def with_long_operation_spinner(message, &block)
+          with_spinner("⏳ #{message}", format: :pulse, &block)
+        end
+
+        # For quick operations
+        def with_quick_spinner(message, &block)
+          with_spinner("⚡ #{message}", format: :dots, &block)
+        end
+
+        # Update spinner message during operation
+        def update_spinner_message(spinner, new_message)
+          spinner.update_title(new_message)
+        end
+
+        # Check if any spinners are active
+        def any_active?
+          @active_spinners.any?(&:spinning?)
+        end
+
+        # Get count of active spinners
+        def active_count
+          @active_spinners.count(&:spinning?)
+        end
+
+        # Force stop all spinners (emergency cleanup)
+        def stop_all
+          @active_spinners.each do |spinner|
+            spinner.stop if spinner.spinning?
+          end
+          @active_spinners.clear
+        end
+
+        private
+
+        def create_spinner(message, format)
+          TTY::Spinner.new(
+            "#{message} :spinner",
+            format: format,
+            success_mark: @pastel.green("✓"),
+            error_mark: @pastel.red("✗"),
+            hide_cursor: true
+          )
+        end
+
+        def start_spinner(spinner)
+          @active_spinners << spinner
+          spinner.start
+        end
+
+        def success_spinner(spinner, message)
+          spinner.success(@pastel.green("✓ #{message}"))
+        end
+
+        def error_spinner(spinner, message)
+          spinner.error(@pastel.red("✗ #{message}"))
+        end
+
+        def cleanup_spinner(spinner)
+          @active_spinners.delete(spinner)
+          # TTY::Spinner handles its own cleanup
+        end
+      end
+
+      # Global instance for easy access
+      SPINNER = SpinnerHelper.new
+
+      # Convenience methods for global access
+      def self.with_spinner(message, **options, &block)
+        SPINNER.with_spinner(message, **options, &block)
+      end
+
+      def self.with_loading_spinner(message, &block)
+        SPINNER.with_loading_spinner(message, &block)
+      end
+
+      def self.with_processing_spinner(message, &block)
+        SPINNER.with_processing_spinner(message, &block)
+      end
+
+      def self.with_saving_spinner(message, &block)
+        SPINNER.with_saving_spinner(message, &block)
+      end
+
+      def self.with_analyzing_spinner(message, &block)
+        SPINNER.with_analyzing_spinner(message, &block)
+      end
+
+      def self.with_building_spinner(message, &block)
+        SPINNER.with_building_spinner(message, &block)
+      end
+    end
+  end
+end