aidp 0.5.0 → 0.8.0

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

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "pastel"
+require_relative "../base"
+require_relative "menu_item"
+require_relative "menu_state"
+require_relative "menu_formatter"
+
+module Aidp
+  module Harness
+    module UI
+      module Navigation
+        # Main hierarchical navigation menu system
+        class MainMenu < Base
+          class MenuError < StandardError; end
+          class InvalidMenuError < MenuError; end
+          class NavigationError < MenuError; end
+
+          def initialize(ui_components = {})
+            super()
+            @prompt = ui_components[:prompt] || TTY::Prompt.new
+            @pastel = Pastel.new
+            @formatter = ui_components[:formatter] || MenuFormatter.new
+            @state_manager = ui_components[:state_manager] || MenuState.new
+            @menu_items = []
+            @current_level = 0
+            @breadcrumb = []
+            @navigation_history = []  # Track all navigation actions
+          end
+
+          def add_menu_item(item)
+            validate_menu_item(item)
+            @menu_items << item
+          end
+
+          def add_menu_items(items)
+            validate_menu_items(items)
+            items.each { |item| add_menu_item(item) }
+          end
+
+          def show_menu(title = "Main Menu")
+            validate_title(title)
+
+            loop do
+              display_menu_header(title)
+              display_breadcrumb
+              display_menu_items
+
+              selection = prompt_for_selection
+              break if handle_selection(selection) == :exit
+            end
+          rescue => e
+            raise NavigationError, "Failed to show menu: #{e.message}"
+          end
+
+          def display_menu(title, menu_items)
+            # Handle nil title case
+            title = "Main Menu" if title.nil?
+            validate_title(title)
+            validate_menu_items(menu_items)
+
+            # Set the menu items for display
+            @menu_items = menu_items
+
+            display_menu_header(title)
+            display_breadcrumb
+            display_menu_items
+
+            # Add navigation instructions if items exist
+            if menu_items.any?
+              puts "Use arrow keys to navigate, Enter to select"
+            else
+              puts "No options available"
+            end
+          rescue => e
+            raise NavigationError, "Failed to display menu: #{e.message}"
+          end
+
+          def navigate_to_submenu(submenu_title)
+            validate_title(submenu_title)
+
+            submenu = find_submenu(submenu_title)
+            raise InvalidMenuError, "Submenu '#{submenu_title}' not found" unless submenu
+
+            @breadcrumb << submenu_title
+            @current_level += 1
+
+            submenu.show_menu(submenu_title)
+          rescue => e
+            raise NavigationError, "Failed to navigate to submenu: #{e.message}"
+          end
+
+          def go_back
+            return false if @breadcrumb.empty?
+
+            @breadcrumb.pop
+            @current_level -= 1
+            true
+          end
+
+          def current_path
+            @breadcrumb.join(" > ")
+          end
+
+          def menu_depth
+            @current_level
+          end
+
+          # Methods expected by tests
+          def select_option(menu_items)
+            @menu_items = menu_items
+            display_menu_items
+
+            max_attempts = 10  # Prevent infinite loops
+            attempts = 0
+
+            loop do
+              attempts += 1
+              break if attempts > max_attempts
+
+              # Use get_user_input for testing compatibility
+              input = get_user_input("Select an option: ")
+
+              # Handle cancel/quit
+              if input.downcase == "q" || input.downcase == "quit" || input.downcase == "cancel"
+                return nil
+              end
+
+              # Handle numeric input
+              if input.match?(/^\d+$/)
+                index = input.to_i - 1
+                if index >= 0 && index < menu_items.length
+                  return menu_items[index]
+                else
+                  puts "Invalid selection"
+                  next
+                end
+              else
+                # Handle text input
+                selected_item = menu_items.find { |item| item.title.downcase == input.downcase }
+                if selected_item
+                  return selected_item
+                else
+                  puts "Invalid selection"
+                  next
+                end
+              end
+            end
+
+            # If we get here, we've exceeded max attempts
+            puts "Too many invalid attempts. Returning first option."
+            menu_items.first
+          end
+
+          def get_user_input(prompt)
+            # Mock method for testing - will be stubbed in tests
+            @prompt.ask(prompt)
+          end
+
+          def navigate_to(section_name)
+            @breadcrumb << section_name
+            @current_level += 1
+            @navigation_history << {action: :navigate_to, section: section_name}
+          end
+
+          def navigate_back
+            return false if @breadcrumb.empty?
+
+            section = @breadcrumb.pop
+            @current_level -= 1
+            @navigation_history << {action: :navigate_back, section: section}
+            true
+          end
+
+          def navigate_to_root
+            @breadcrumb.clear
+            @current_level = 0
+          end
+
+          def get_navigation_history
+            # Return the complete navigation history
+            @navigation_history
+          end
+
+          def clear_navigation_history
+            @breadcrumb.clear
+            @current_level = 0
+            @navigation_history.clear
+          end
+
+          def at_root?
+            @breadcrumb.empty?
+          end
+
+          def display_navigation_help
+            puts "Navigation Help"
+            puts "Use arrow keys to navigate"
+            puts "Press Enter to select"
+            puts "Press Escape to go back"
+          end
+
+          # Additional methods expected by tests
+          def current_section
+            @breadcrumb.last || "Home"
+          end
+
+          def get_breadcrumb_path
+            ["Home"] + @breadcrumb
+          end
+
+          def navigation_depth
+            @current_level
+          end
+
+          def can_navigate_back?
+            !@breadcrumb.empty?
+          end
+
+          # Make display_breadcrumb public for testing
+          def display_breadcrumb
+            if @breadcrumb.empty?
+              puts "Home"
+            else
+              breadcrumb_text = @formatter.format_breadcrumb(@breadcrumb)
+              puts(breadcrumb_text)
+            end
+          end
+
+          private
+
+          def validate_menu_item(item)
+            raise InvalidMenuError, "Menu item must be a MenuItem" unless item.is_a?(MenuItem)
+          end
+
+          def validate_menu_items(items)
+            raise InvalidMenuError, "Menu items must be an array" unless items.is_a?(Array)
+          end
+
+          def validate_title(title)
+            raise InvalidMenuError, "Title cannot be empty" if title.to_s.strip.empty?
+          end
+
+          def display_menu_header(title)
+            formatted_title = @formatter.format_menu_title(title)
+            puts(formatted_title)
+            puts(@formatter.format_separator)
+          end
+
+          def display_menu_items
+            @menu_items.each_with_index do |item, index|
+              formatted_item = @formatter.format_menu_item(item, index + 1)
+              puts(formatted_item)
+            end
+          end
+
+          def prompt_for_selection
+            options = build_selection_options
+            @prompt.ask("Select an option:") do |handler|
+              options.each { |option| handler.option(option) }
+            end
+          end
+
+          def build_selection_options
+            options = @menu_items.map(&:title)
+            options << "Back" unless @breadcrumb.empty?
+            options << "Exit"
+            options
+          end
+
+          def handle_selection(selection)
+            return :exit if selection == "Exit"
+            return :back if selection == "Back"
+
+            selected_item = find_menu_item(selection)
+            execute_menu_item(selected_item)
+          end
+
+          def find_menu_item(title)
+            @menu_items.find { |item| item.title == title }
+          end
+
+          def find_submenu(title)
+            @menu_items.find { |item| item.submenu? && item.title == title }
+          end
+
+          def execute_menu_item(item)
+            case item.type
+            when :action
+              execute_action(item)
+            when :submenu
+              navigate_to_submenu(item.title)
+            when :workflow
+              execute_workflow(item)
+            else
+              raise InvalidMenuError, "Unknown menu item type: #{item.type}"
+            end
+          end
+
+          def execute_action(item)
+            item.action&.call
+          end
+
+          def execute_workflow(item)
+            item.workflow&.call
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Aidp
+  module Harness
+    module UI
+      module Navigation
+        # Formats menu display elements
+        class MenuFormatter
+          def initialize
+            @pastel = Pastel.new
+          end
+
+          def format_menu_title(title)
+            @pastel.bold(@pastel.blue("📋 #{title}"))
+          end
+
+          def format_separator
+            "─" * 50
+          end
+
+          def format_breadcrumb(breadcrumbs)
+            breadcrumb_text = breadcrumbs.join(" > ")
+            @pastel.dim("📍 #{breadcrumb_text}")
+          end
+
+          def format_menu_item(item, index)
+            return format_separator_item if item.separator?
+
+            prefix = format_item_prefix(index)
+            title = format_item_title(item)
+            description = format_item_description(item)
+            status = format_item_status(item)
+
+            "#{prefix} #{title}#{description}#{status}"
+          end
+
+          def format_item_prefix(index)
+            @pastel.bold("#{index}.")
+          end
+
+          def format_item_title(item)
+            if item.disabled?
+              @pastel.dim(item.title)
+            elsif item.hidden?
+              @pastel.dim(item.title)
+            else
+              @pastel.bold(item.title)
+            end
+          end
+
+          def format_item_description(item)
+            return "" unless item.description
+
+            " #{@pastel.dim("- #{item.description}")}"
+          end
+
+          def format_item_status(item)
+            return " #{@pastel.red("[DISABLED]")}" if item.disabled?
+            return " #{@pastel.yellow("[HIDDEN]")}" if item.hidden?
+            ""
+          end
+
+          def format_separator_item
+            @pastel.dim("────────────────────────────────────────")
+          end
+
+          def format_shortcut(shortcut)
+            @pastel.dim("(#{shortcut})")
+          end
+
+          def format_menu_depth(depth)
+            @pastel.dim("Level #{depth}")
+          end
+
+          def format_navigation_prompt
+            @pastel.bold("Select an option:")
+          end
+
+          def format_back_option
+            @pastel.dim("← Back")
+          end
+
+          def format_exit_option
+            @pastel.red("✗ Exit")
+          end
+
+          def format_workflow_title(workflow_name)
+            @pastel.bold(@pastel.green("🔄 #{workflow_name} Workflow"))
+          end
+
+          def format_action_title(action_name)
+            @pastel.bold(@pastel.blue("⚡ #{action_name}"))
+          end
+
+          def format_submenu_title(submenu_name)
+            @pastel.bold(@pastel.yellow("📁 #{submenu_name}"))
+          end
+
+          def format_error_message(error)
+            "#{@pastel.red("❌ Error:")} #{error}"
+          end
+
+          def format_success_message(message)
+            @pastel.green("✅ #{message}")
+          end
+
+          def format_warning_message(message)
+            @pastel.yellow("⚠️ #{message}")
+          end
+
+          def format_info_message(message)
+            @pastel.blue("ℹ️ #{message}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    module UI
+      module Navigation
+        # Represents a single menu item in the navigation system
+        class MenuItem
+          class MenuItemError < StandardError; end
+          class InvalidTypeError < MenuItemError; end
+
+          VALID_TYPES = [:action, :submenu, :workflow, :separator].freeze
+
+          def initialize(title, type = :action, options = {})
+            @title = title
+            @type = type
+            @action = options[:action]
+            @workflow = options[:workflow]
+            @submenu = options[:submenu]
+            @description = options[:description]
+            @shortcut = options[:shortcut]
+            @enabled = options.fetch(:enabled, true)
+            @visible = options.fetch(:visible, true)
+
+            validate_attributes
+          end
+
+          attr_reader :title, :type, :action, :workflow, :submenu, :description, :shortcut
+          attr_accessor :enabled, :visible
+
+          def action?
+            @type == :action
+          end
+
+          def submenu?
+            @type == :submenu
+          end
+
+          def workflow?
+            @type == :workflow
+          end
+
+          def separator?
+            @type == :separator
+          end
+
+          def enabled?
+            @enabled
+          end
+
+          def visible?
+            @visible
+          end
+
+          def disabled?
+            !enabled?
+          end
+
+          def hidden?
+            !visible?
+          end
+
+          def execute
+            case @type
+            when :action
+              execute_action
+            when :workflow
+              execute_workflow
+            when :submenu
+              execute_submenu
+            when :separator
+              execute_separator
+            else
+              raise InvalidTypeError, "Unknown menu item type: #{@type}"
+            end
+          end
+
+          def to_s
+            "#{@title} (#{@type})"
+          end
+
+          private
+
+          def validate_attributes
+            validate_title
+            validate_type
+            validate_type_specific_attributes
+          end
+
+          def validate_title
+            raise MenuItemError, "Title cannot be empty" if @title.to_s.strip.empty?
+          end
+
+          def validate_type
+            unless VALID_TYPES.include?(@type)
+              raise InvalidTypeError, "Invalid type: #{@type}. Must be one of: #{VALID_TYPES.join(", ")}"
+            end
+          end
+
+          def validate_type_specific_attributes
+            case @type
+            when :action
+              validate_action_attributes
+            when :workflow
+              validate_workflow_attributes
+            when :submenu
+              validate_submenu_attributes
+            end
+          end
+
+          def validate_action_attributes
+            raise MenuItemError, "Action items must have an action" unless @action.respond_to?(:call)
+          end
+
+          def validate_workflow_attributes
+            raise MenuItemError, "Workflow items must have a workflow" unless @workflow.respond_to?(:call)
+          end
+
+          def validate_submenu_attributes
+            raise MenuItemError, "Submenu items must have a submenu" unless @submenu.is_a?(MainMenu)
+          end
+
+          def execute_action
+            @action&.call
+          end
+
+          def execute_workflow
+            @workflow&.call
+          end
+
+          def execute_submenu
+            @submenu&.show_menu(@title)
+          end
+
+          def execute_separator
+            # Separators don't execute anything
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    module UI
+      module Navigation
+        # Manages navigation state and history
+        class MenuState
+          class StateError < StandardError; end
+          class InvalidStateError < StateError; end
+
+          def initialize
+            @navigation_history = []
+            @current_menu = nil
+            @menu_stack = []
+            @breadcrumbs = []
+            @last_selection = nil
+          end
+
+          def push_menu(menu_title)
+            validate_menu_title(menu_title)
+
+            @menu_stack << menu_title
+            @breadcrumbs << menu_title
+            @current_menu = menu_title
+          end
+
+          def pop_menu
+            return nil if @menu_stack.empty?
+
+            @menu_stack.pop
+            @breadcrumbs.pop
+            @current_menu = @menu_stack.last
+            @current_menu
+          end
+
+          def set_current_menu(menu_title)
+            validate_menu_title(menu_title)
+            @current_menu = menu_title
+          end
+
+          def record_selection(selection)
+            @last_selection = selection
+            @navigation_history << {
+              menu: @current_menu,
+              selection: selection,
+              timestamp: Time.now
+            }
+          end
+
+          def record_workflow_mode_selection(mode)
+            @navigation_history << {
+              menu: @current_menu,
+              selection: "workflow_mode: #{mode}",
+              timestamp: Time.now
+            }
+          end
+
+          def record_keyboard_navigation(key, action)
+            @navigation_history << {
+              menu: @current_menu,
+              selection: "keyboard: #{key} -> #{action}",
+              timestamp: Time.now
+            }
+          end
+
+          def record_progressive_disclosure(level, action)
+            @navigation_history << {
+              menu: @current_menu,
+              selection: "progressive: level #{level} -> #{action}",
+              timestamp: Time.now
+            }
+          end
+
+          def get_navigation_history
+            @navigation_history.dup
+          end
+
+          def get_breadcrumbs
+            @breadcrumbs.dup
+          end
+
+          def get_menu_stack
+            @menu_stack.dup
+          end
+
+          attr_reader :current_menu
+
+          attr_reader :last_selection
+
+          def menu_depth
+            @menu_stack.size
+          end
+
+          def can_go_back?
+            @menu_stack.size > 1
+          end
+
+          def clear_history
+            @navigation_history.clear
+          end
+
+          def clear_breadcrumbs
+            @breadcrumbs.clear
+          end
+
+          def clear_menu_stack
+            @menu_stack.clear
+            @current_menu = nil
+          end
+
+          def reset
+            clear_history
+            clear_breadcrumbs
+            clear_menu_stack
+            @last_selection = nil
+          end
+
+          def export_state
+            {
+              current_menu: @current_menu,
+              menu_stack: @menu_stack,
+              breadcrumbs: @breadcrumbs,
+              last_selection: @last_selection,
+              navigation_history: @navigation_history,
+              menu_depth: menu_depth
+            }
+          end
+
+          private
+
+          def validate_menu_title(menu_title)
+            raise InvalidStateError, "Menu title cannot be empty" if menu_title.to_s.strip.empty?
+          end
+        end
+      end
+    end
+  end
+end