aidp 0.7.0 → 0.8.1

data/lib/aidp/harness/ui/navigation/submenu.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "main_menu"
+
+module Aidp
+  module Harness
+    module UI
+      module Navigation
+        # Specialized submenu for drill-down functionality
+        class SubMenu < MainMenu
+          class SubMenuError < MenuError; end
+          class InvalidSubMenuError < SubMenuError; end
+
+          def initialize(title, parent_menu = nil, ui_components = {})
+            super(ui_components)
+            @title = title
+            @parent_menu = parent_menu
+            @submenu_items = []
+            @drill_down_enabled = true
+            @max_depth = 5
+          end
+
+          attr_reader :title, :parent_menu
+          attr_accessor :drill_down_enabled, :max_depth
+
+          def add_submenu_item(item)
+            validate_submenu_item(item)
+            @submenu_items << item
+            add_menu_item(item)
+          end
+
+          def add_submenu_items(items)
+            validate_submenu_items(items)
+            items.each { |item| add_submenu_item(item) }
+          end
+
+          def show_submenu
+            return unless can_show_submenu?
+
+            display_submenu_header
+            display_submenu_items
+            handle_submenu_interaction
+          rescue => e
+            raise SubMenuError, "Failed to show submenu: #{e.message}"
+          end
+
+          def can_show_submenu?
+            @drill_down_enabled && @submenu_items.any? && within_depth_limit?
+          end
+
+          def within_depth_limit?
+            @current_level < @max_depth
+          end
+
+          def has_parent?
+            !@parent_menu.nil?
+          end
+
+          def get_parent_path
+            return [] unless has_parent?
+
+            path = [@title]
+            current_parent = @parent_menu
+
+            while current_parent&.parent_menu
+              path.unshift(current_parent.title)
+              current_parent = current_parent.parent_menu
+            end
+
+            path
+          end
+
+          def get_full_path
+            parent_path = get_parent_path
+            parent_path << @title
+            parent_path
+          end
+
+          def create_child_submenu(title)
+            validate_title(title)
+            raise InvalidSubMenuError, "Maximum depth reached" unless within_depth_limit?
+
+            child_submenu = SubMenu.new(title, self, @ui_components)
+            child_submenu.max_depth = @max_depth
+            child_submenu
+          end
+
+          def navigate_to_parent
+            return false unless has_parent?
+
+            @parent_menu.show_menu(@parent_menu.title)
+            true
+          end
+
+          private
+
+          def validate_submenu_item(item)
+            validate_menu_item(item)
+            raise InvalidSubMenuError, "Submenu items must be MenuItems" unless item.is_a?(MenuItem)
+          end
+
+          def validate_submenu_items(items)
+            raise InvalidSubMenuError, "Submenu items must be an array" unless items.is_a?(Array)
+          end
+
+          def display_submenu_header
+            @prompt.say(@formatter.format_submenu_title(@title))
+            @prompt.say(@formatter.format_separator)
+
+            if has_parent?
+              parent_path = get_parent_path.join(" > ")
+              @prompt.say(@formatter.format_parent_path(parent_path))
+            end
+          end
+
+          def display_submenu_items
+            @submenu_items.each_with_index do |item, index|
+              formatted_item = @formatter.format_submenu_item(item, index + 1)
+              @prompt.say(formatted_item)
+            end
+          end
+
+          def handle_submenu_interaction
+            selection = prompt_for_submenu_selection
+            handle_submenu_selection(selection)
+          end
+
+          def prompt_for_submenu_selection
+            options = build_submenu_options
+            @prompt.ask("Select an option:") do |handler|
+              options.each { |option| handler.option(option) }
+            end
+          end
+
+          def build_submenu_options
+            options = @submenu_items.map(&:title)
+            options << "Back to Parent" if has_parent?
+            options << "Back to Main Menu"
+            options << "Exit"
+            options
+          end
+
+          def handle_submenu_selection(selection)
+            case selection
+            when "Back to Parent"
+              navigate_to_parent
+            when "Back to Main Menu"
+              navigate_to_main_menu
+            when "Exit"
+              :exit
+            else
+              handle_item_selection(selection)
+            end
+          end
+
+          def handle_item_selection(selection)
+            selected_item = find_submenu_item(selection)
+            return unless selected_item
+
+            execute_submenu_item(selected_item)
+          end
+
+          def find_submenu_item(title)
+            @submenu_items.find { |item| item.title == title }
+          end
+
+          def execute_submenu_item(item)
+            case item.type
+            when :action
+              execute_action(item)
+            when :submenu
+              navigate_to_child_submenu(item)
+            when :workflow
+              execute_workflow(item)
+            else
+              raise InvalidSubMenuError, "Unknown submenu item type: #{item.type}"
+            end
+          end
+
+          def navigate_to_child_submenu(item)
+            child_submenu = create_child_submenu(item.title)
+            child_submenu.show_submenu
+          end
+
+          def navigate_to_main_menu
+            # Navigate to the root menu
+            root_menu = find_root_menu
+            root_menu&.show_menu
+          end
+
+          def find_root_menu
+            current = self
+            while current.parent_menu
+              current = current.parent_menu
+            end
+            current
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/ui/navigation/workflow_selector.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "pastel"
+require_relative "../base"
+require_relative "menu_item"
+
+module Aidp
+  module Harness
+    module UI
+      module Navigation
+        # Handles workflow mode selection (simple vs advanced)
+        class WorkflowSelector < Base
+          class WorkflowError < StandardError; end
+          class InvalidModeError < WorkflowError; end
+          class SelectionError < WorkflowError; end
+
+          WORKFLOW_MODES = {
+            simple: {
+              name: "Simple Mode",
+              description: "Predefined workflows with guided templates",
+              icon: "🚀"
+            },
+            advanced: {
+              name: "Advanced Mode",
+              description: "Custom workflow configuration",
+              icon: "⚙️"
+            }
+          }.freeze
+
+          def initialize(ui_components = {})
+            super()
+            @prompt = ui_components[:prompt] || TTY::Prompt.new
+            @pastel = Pastel.new
+            @formatter = ui_components[:formatter] || WorkflowFormatter.new
+            @state_manager = ui_components[:state_manager]
+          end
+
+          def select_workflow_mode
+            display_mode_selection
+            selection = prompt_for_mode_selection
+            validate_selection(selection)
+
+            selected_mode = parse_selection(selection)
+            record_selection(selected_mode)
+            selected_mode
+          rescue => e
+            raise SelectionError, "Failed to select workflow mode: #{e.message}"
+          end
+
+          def show_mode_description(mode)
+            validate_mode(mode)
+
+            mode_info = WORKFLOW_MODES[mode]
+            display_mode_info(mode_info)
+          end
+
+          def get_available_modes
+            WORKFLOW_MODES.keys
+          end
+
+          def get_mode_info(mode)
+            validate_mode(mode)
+            WORKFLOW_MODES[mode]
+          end
+
+          def is_simple_mode?(mode)
+            mode == :simple
+          end
+
+          def is_advanced_mode?(mode)
+            mode == :advanced
+          end
+
+          private
+
+          def display_mode_selection
+            @prompt.say(@formatter.format_selector_title)
+            @prompt.say(@formatter.format_separator)
+
+            WORKFLOW_MODES.each_with_index do |(key, info), index|
+              display_mode_option(key, info, index + 1)
+            end
+
+            @prompt.say(@formatter.format_separator)
+          end
+
+          def display_mode_option(mode_key, mode_info, index)
+            formatted_option = @formatter.format_mode_option(mode_key, mode_info, index)
+            @prompt.say(formatted_option)
+          end
+
+          def display_mode_info(mode_info)
+            @prompt.say(@formatter.format_mode_info(mode_info))
+          end
+
+          def prompt_for_mode_selection
+            options = build_mode_options
+            @prompt.ask("Select workflow mode:") do |handler|
+              options.each { |option| handler.option(option) }
+            end
+          end
+
+          def build_mode_options
+            WORKFLOW_MODES.map { |key, info| "#{info[:icon]} #{info[:name]}" }
+          end
+
+          def validate_selection(selection)
+            raise InvalidModeError, "Selection cannot be empty" if selection.to_s.strip.empty?
+          end
+
+          def parse_selection(selection)
+            WORKFLOW_MODES.each do |key, info|
+              return key if selection.include?(info[:name])
+            end
+
+            raise InvalidModeError, "Invalid selection: #{selection}"
+          end
+
+          def validate_mode(mode)
+            unless WORKFLOW_MODES.key?(mode)
+              raise InvalidModeError, "Invalid mode: #{mode}. Must be one of: #{WORKFLOW_MODES.keys.join(", ")}"
+            end
+          end
+
+          def record_selection(mode)
+            @state_manager&.record_workflow_mode_selection(mode)
+          end
+        end
+
+        # Formats workflow selection display
+        class WorkflowFormatter
+          def initialize
+            @pastel = Pastel.new
+          end
+
+          def format_selector_title
+            @pastel.bold(@pastel.blue("🎯 Workflow Mode Selection"))
+          end
+
+          def format_separator
+            "─" * 60
+          end
+
+          def format_mode_option(mode_key, mode_info, index)
+            icon = mode_info[:icon]
+            name = mode_info[:name]
+            description = mode_info[:description]
+
+            "#{@pastel.bold("#{index}.")} #{@pastel.bold("#{icon} #{name}")}\n   #{@pastel.dim(description)}"
+          end
+
+          def format_mode_info(mode_info)
+            icon = mode_info[:icon]
+            name = mode_info[:name]
+            description = mode_info[:description]
+
+            "#{@pastel.bold(@pastel.green("#{icon} #{name}"))}\n#{@pastel.dim(description)}"
+          end
+
+          def format_selected_mode(mode)
+            mode_info = WorkflowSelector::WORKFLOW_MODES[mode]
+            "#{@pastel.green("✓ Selected:")} #{@pastel.bold("#{mode_info[:icon]} #{mode_info[:name]}")}"
+          end
+
+          def format_mode_switch(from_mode, to_mode)
+            from_info = WorkflowSelector::WORKFLOW_MODES[from_mode]
+            to_info = WorkflowSelector::WORKFLOW_MODES[to_mode]
+
+            "#{@pastel.yellow("🔄 Switching from")} #{@pastel.bold(from_info[:name])} #{@pastel.yellow("to")} #{@pastel.bold(to_info[:name])}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require "tty-progressbar"
+require "pastel"
+require_relative "base"
+
+module Aidp
+  module Harness
+    module UI
+      # Handles progress display using CLI UI progress bars
+      class ProgressDisplay < Base
+        class ProgressError < StandardError; end
+        class InvalidProgressError < ProgressError; end
+        class DisplayError < ProgressError; end
+
+        attr_reader :refresh_interval
+
+        def initialize(ui_components = {})
+          super()
+          @progress = ui_components[:progress] || TTY::ProgressBar
+          @pastel = Pastel.new
+          @formatter = ui_components[:formatter] || ProgressFormatter.new
+          @display_history = []
+          @auto_refresh_enabled = false
+          @refresh_interval = 1.0
+          @refresh_thread = nil
+          @output = ui_components[:output] || $stdout
+          @spinner_class = begin
+            ui_components[:spinner] || TTY::Spinner
+          rescue
+            nil
+          end
+          @spinner = nil
+        end
+
+        # Simple spinner management used by component specs
+        def start_spinner(message = "Loading...")
+          return unless @spinner_class
+          @spinner = @spinner_class.new("#{message} :spinner", format: :dots, output: @output)
+          @spinner.start
+        end
+
+        def stop_spinner
+          @spinner&.stop
+          @spinner = nil
+        end
+
+        def show_progress(total_steps, &block)
+          validate_total_steps(total_steps)
+
+          progress_bar = @progress.new(
+            "[:bar] :percent% :current/:total",
+            total: total_steps,
+            width: 30,
+            output: @output
+          )
+
+          execute_progress_steps(progress_bar, total_steps, &block)
+        rescue => e
+          raise DisplayError, "Failed to display progress: #{e.message}"
+        end
+
+        def update_progress(bar, message = nil)
+          validate_progress_bar(bar)
+
+          bar.tick
+          bar.update_title(message) if message
+        rescue => e
+          raise DisplayError, "Failed to update progress: #{e.message}"
+        end
+
+        def show_step_progress(step_name, total_substeps, &block)
+          validate_step_inputs(step_name, total_substeps)
+
+          formatted_title = @formatter.format_step_title(step_name)
+          @progress.progress do |bar|
+            execute_substeps(bar, total_substeps, formatted_title, &block)
+          end
+        rescue => e
+          raise DisplayError, "Failed to display step progress: #{e.message}"
+        end
+
+        def show_indeterminate_progress(message)
+          validate_message(message)
+
+          @progress.progress do |bar|
+            bar.update_title(message)
+            yield(bar) if block_given?
+          end
+        rescue => e
+          raise DisplayError, "Failed to display indeterminate progress: #{e.message}"
+        end
+
+        def display_progress(progress_data, display_type = :standard)
+          validate_progress_data(progress_data)
+          validate_display_type(display_type)
+
+          case display_type
+          when :standard
+            display_standard_progress(progress_data)
+          when :detailed
+            display_detailed_progress(progress_data)
+          when :minimal
+            display_minimal_progress(progress_data)
+          end
+
+          record_display_history(progress_data, display_type)
+        rescue InvalidProgressError => e
+          raise e
+        rescue => e
+          raise DisplayError, "Failed to display progress: #{e.message}"
+        end
+
+        def display_multiple_progress(progress_items, display_type = :standard)
+          raise ArgumentError, "Progress items must be an array" unless progress_items.is_a?(Array)
+
+          if progress_items.empty?
+            @output.puts @pastel.dim("No progress items to display.")
+            return
+          end
+
+          progress_items.each do |item|
+            display_progress(item, display_type)
+          end
+        end
+
+        def get_display_history
+          @display_history.dup
+        end
+
+        def clear_display_history
+          @display_history = []
+        end
+
+        def start_auto_refresh(interval)
+          return if @auto_refresh_enabled
+
+          @refresh_interval = interval
+          @auto_refresh_enabled = true
+          @refresh_thread = Thread.new do
+            while @auto_refresh_enabled
+              yield if block_given?
+              sleep @refresh_interval
+            end
+          end
+        end
+
+        def stop_auto_refresh
+          @auto_refresh_enabled = false
+          @refresh_thread&.join
+          @refresh_thread = nil
+        end
+
+        def auto_refresh_enabled?
+          @auto_refresh_enabled
+        end
+
+        private
+
+        def validate_total_steps(total_steps)
+          raise InvalidProgressError, "Total steps must be positive" unless total_steps > 0
+        end
+
+        def validate_progress_bar(bar)
+          raise InvalidProgressError, "Progress bar cannot be nil" if bar.nil?
+        end
+
+        def validate_step_inputs(step_name, total_substeps)
+          raise InvalidProgressError, "Step name cannot be empty" if step_name.to_s.strip.empty?
+          raise InvalidProgressError, "Total substeps must be positive" unless total_substeps > 0
+        end
+
+        def validate_message(message)
+          raise InvalidProgressError, "Message cannot be empty" if message.to_s.strip.empty?
+        end
+
+        def execute_progress_steps(bar, total_steps, &block)
+          total_steps.times do
+            yield(bar) if block_given?
+            bar.tick
+          end
+        end
+
+        def execute_substeps(bar, total_substeps, title, &block)
+          bar.update_title(title)
+          total_substeps.times do |index|
+            substep_title = @formatter.format_substep_title(title, index + 1, total_substeps)
+            bar.update_title(substep_title)
+            yield(bar, index) if block_given?
+            bar.tick
+          end
+        end
+
+        def display_standard_progress(progress_data)
+          progress = progress_data[:progress] || 0
+          message = progress_data[:message] || "Processing..."
+          step_info = (progress_data[:current_step] && progress_data[:total_steps]) ?
+            " (Step: #{progress_data[:current_step]}/#{progress_data[:total_steps]})" :
+            " (Step: #{progress_data[:current_step]})"
+          task_id = progress_data[:id] ? "[#{progress_data[:id]}] " : ""
+
+          @output.puts "#{task_id}#{progress}% #{message}#{step_info}"
+        end
+
+        def display_detailed_progress(progress_data)
+          progress = progress_data[:progress] || 0
+          message = progress_data[:message] || "Processing..."
+          current_step = progress_data[:current_step] || "N/A"
+          total_steps = progress_data[:total_steps] || "N/A"
+          started_at = progress_data[:started_at] ? progress_data[:started_at].strftime("%H:%M:%S") : "N/A"
+          eta = progress_data[:eta] || "N/A"
+
+          @output.puts "Progress: #{progress}% - #{message} (Step: #{current_step}/#{total_steps}, Started: #{started_at}, ETA: #{eta})"
+        end
+
+        def display_minimal_progress(progress_data)
+          progress = progress_data[:progress] || 0
+          message = progress_data[:message] || "Processing..."
+          @output.puts "#{@pastel.blue("Progress:")} #{progress}% - #{message}"
+        end
+
+        def create_progress_bar(progress)
+          TTY::ProgressBar.new(
+            "#{@pastel.green("[:bar]")} :percent",
+            total: 100,
+            width: 30,
+            current: progress,
+            output: @output
+          )
+        end
+
+        def validate_progress_data(progress_data)
+          raise ArgumentError, "Progress data must be a hash" unless progress_data.is_a?(Hash)
+          progress = progress_data[:progress]
+          if progress && (!progress.is_a?(Numeric) || progress < 0 || progress > 100)
+            raise InvalidProgressError, "Progress must be a number between 0 and 100"
+          end
+        end
+
+        def validate_display_type(display_type)
+          valid_types = [:standard, :detailed, :minimal]
+          unless valid_types.include?(display_type)
+            raise InvalidProgressError, "Invalid display type: #{display_type}. Must be one of: #{valid_types.join(", ")}"
+          end
+        end
+
+        def record_display_history(progress_data, display_type)
+          @display_history << {
+            progress_data: progress_data.dup,
+            display_type: display_type,
+            timestamp: Time.now
+          }
+        end
+      end
+
+      # Formats progress display text
+      class ProgressFormatter
+        def format_step_title(step_name)
+          "Step: #{step_name}"
+        end
+
+        def format_substep_title(step_title, current, total)
+          "#{step_title} (#{current}/#{total})"
+        end
+
+        def format_percentage(current, total)
+          percentage = (current.to_f / total * 100).round(1)
+          "#{percentage}%"
+        end
+
+        def format_eta(remaining_steps, average_time_per_step)
+          return "Unknown" unless average_time_per_step > 0
+
+          eta_seconds = remaining_steps * average_time_per_step
+          format_duration(eta_seconds)
+        end
+      end
+    end
+  end
+end