swarm_cli 2.1.13 → 3.0.0.alpha2

data/lib/swarm_cli/v3/dropdown.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module V3
+    # Reusable dropdown component for displaying and navigating a list of items.
+    #
+    # The Dropdown component provides a simple, modular interface for list selection
+    # without any knowledge of file systems, autocomplete, or terminal rendering.
+    # It manages state (items, selection) and provides methods for navigation and
+    # rendering.
+    #
+    # @example Basic usage
+    #   dropdown = Dropdown.new(items: ["option1", "option2", "option3"])
+    #   dropdown.select_next          # Move down
+    #   dropdown.selected_item        # => "option2"
+    #   dropdown.render               # => ["1. option1", "2. \e[7moption2\e[0m", ...]
+    #
+    # @example Limited visibility
+    #   dropdown = Dropdown.new(items: (1..100).to_a, max_visible: 5)
+    #   dropdown.render.size          # => 5 (only shows first 5 items)
+    class Dropdown
+      # @return [Array<String>] the list of items in the dropdown
+      attr_reader :items
+
+      # @return [Integer] the currently selected index (0-based)
+      attr_reader :selected_index
+
+      # Create a new dropdown with the given items.
+      #
+      # @param items [Array<String>] the list of items to display
+      # @param max_visible [Integer] maximum number of items to show at once
+      #
+      # @raise [ArgumentError] if items is empty
+      #
+      # @example
+      #   dropdown = Dropdown.new(items: ["file1.rb", "file2.rb"], max_visible: 5)
+      def initialize(items:, max_visible: 5)
+        raise ArgumentError, "items cannot be empty" if items.empty?
+
+        @items = items
+        @selected_index = 0
+        @max_visible = max_visible
+      end
+
+      # Move selection to the previous item (wraps to bottom).
+      #
+      # @return [void]
+      #
+      # @example
+      #   dropdown.selected_index  # => 2
+      #   dropdown.select_previous
+      #   dropdown.selected_index  # => 1
+      def select_previous
+        @selected_index = (@selected_index - 1) % @items.size
+      end
+
+      # Move selection to the next item (wraps to top).
+      #
+      # @return [void]
+      #
+      # @example
+      #   dropdown.selected_index  # => 1
+      #   dropdown.select_next
+      #   dropdown.selected_index  # => 2
+      def select_next
+        @selected_index = (@selected_index + 1) % @items.size
+      end
+
+      # Get the currently selected item.
+      #
+      # @return [String] the selected item
+      #
+      # @example
+      #   dropdown.select_next
+      #   dropdown.selected_item  # => "option2"
+      def selected_item
+        @items[@selected_index]
+      end
+
+      # Get the first item in the list.
+      #
+      # @return [String] the first item
+      #
+      # @example
+      #   dropdown.first_item  # => "option1"
+      def first_item
+        @items.first
+      end
+
+      # Render the dropdown as a numbered list with highlighting.
+      #
+      # The selected item is rendered with reverse video highlighting.
+      # Non-selected items are rendered with dim styling.
+      # Only the first max_visible items are included.
+      #
+      # @return [Array<String>] array of formatted lines
+      #
+      # @example
+      #   dropdown = Dropdown.new(items: ["a", "b", "c"], max_visible: 5)
+      #   dropdown.select_next
+      #   dropdown.render
+      #   # => ["1. \e[2ma\e[0m", "2. \e[7mb\e[0m", "3. \e[2mc\e[0m"]
+      def render
+        visible_items = @items.first(@max_visible)
+
+        visible_items.map.with_index do |item, idx|
+          prefix = "#{idx + 1}. "
+          if idx == @selected_index
+            ANSIColors.reverse(prefix + item)
+          else
+            ANSIColors.dim(prefix + item)
+          end
+        end
+      end
+
+      # Check if the dropdown has no items.
+      #
+      # @return [Boolean] true if items array is empty
+      #
+      # @note This should never be true due to the constructor validation,
+      #   but is provided for completeness.
+      #
+      # @example
+      #   dropdown.empty?  # => false
+      def empty?
+        @items.empty?
+      end
+    end
+  end
+end

data/lib/swarm_cli/v3/event_renderer.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module V3
+    # Stateless formatter for V3 agent events.
+    #
+    # Converts event hashes (emitted by {SwarmSDK::V3::EventStream}) into
+    # styled terminal strings. Returns +nil+ for unrecognized event types
+    # so the caller can silently skip them.
+    #
+    # @example
+    #   event = { type: "tool_call", tool: "Read", arguments: { file_path: "foo.rb" } }
+    #   EventRenderer.format(event)
+    #   # => "  \u{1F4D6} \e[2mRead(file_path: \"foo.rb\")\e[0m"
+    module EventRenderer
+      TOOL_EMOJIS = {
+        "Read" => "\u{1F4D6}",
+        "Write" => "\u{270F}\u{FE0F}",
+        "Edit" => "\u{1F527}",
+        "Bash" => "\u{1F4BB}",
+        "Grep" => "\u{1F50D}",
+        "Glob" => "\u{1F4C2}",
+        "Think" => "\u{1F4AD}",
+        "Reboot" => "\u{1F504}",
+        "Clock" => "\u{1F550}",
+        "SubTask" => "\u{1F41D}",
+      }.freeze
+
+      class << self
+        # Format an event hash into a styled terminal string.
+        #
+        # @param event [Hash] event data with at least a +:type+ key
+        # @return [String, nil] formatted string, or nil if the event type is unknown
+        #
+        # @example tool_call event
+        #   EventRenderer.format(type: "tool_call", tool: "Bash", arguments: { command: "ls" })
+        #
+        # @example subtask event
+        #   EventRenderer.format(type: "subtask_spawned", title: "research", depth: 1)
+        def format(event)
+          case event[:type]
+          when "tool_call"
+            emoji = TOOL_EMOJIS[event[:tool]] || "\u{1F527}"
+            args = format_tool_args(event[:arguments])
+            "  #{emoji} #{ANSIColors.dim("#{event[:tool]}(#{args})")}"
+          when "tool_result"
+            format_tool_result(event[:result_preview])
+          when "subtask_spawned"
+            ANSIColors.magenta("  \u{1F41D} SubTask spawned: #{event[:title]} (depth: #{event[:depth]})")
+          when "subtask_completed"
+            ANSIColors.green("  \u{2705} SubTask completed: #{event[:title]}")
+          when "subtask_failed"
+            ANSIColors.red("  \u{274C} SubTask failed: #{event[:title]} \u{2014} #{event[:error]}")
+          when "memory_retrieval", "memory_wait_ingestion", "memory_eviction"
+            label = event[:type].sub("memory_", "").tr("_", " ")
+            ANSIColors.dim("  \u{1F9E0} #{label} (#{event[:elapsed_ms]}ms)")
+          when "tool_skipped"
+            ANSIColors.yellow("  \u{23ED}\u{FE0F} #{event[:tool]} skipped (steering)")
+          when "steering_injected"
+            ANSIColors.yellow("  \u{1F3AF} Steering injected (#{event[:message_count]} message#{"s" if event[:message_count] != 1})")
+          when "follow_up_injected"
+            ANSIColors.cyan("  \u{1F4CB} Follow-up processing (#{event[:message_count]} message#{"s" if event[:message_count] != 1})")
+          when "memory_defrag_start"
+            ANSIColors.cyan("  \u{1F9F9} Starting defrag (#{event[:total_cards]} cards, #{event[:total_clusters]} clusters)")
+          when "memory_defrag_complete"
+            ANSIColors.green("  \u{2705} Defrag complete in #{event[:elapsed_ms]}ms")
+          end
+        end
+
+        # Format a defrag progress event for activity indicator display.
+        #
+        # @param event [Hash] defrag progress event
+        # @return [String, nil] progress string or nil
+        def format_defrag_progress(event)
+          return unless event[:type] == "memory_defrag_progress"
+
+          pct = (event[:overall_current].to_f / event[:overall_total] * 100).round
+          "\u{1F9F9} [#{pct}%] #{event[:description]}"
+        end
+
+        # Format a memory event as a short activity status string.
+        #
+        # Used by the activity indicator to show memory operations inline
+        # on the "Working..." line rather than as separate output lines.
+        #
+        # @param event [Hash] memory event with +:type+ and +:elapsed_ms+
+        # @return [String, nil] status string or nil if not a memory event
+        def format_activity(event)
+          case event[:type]
+          when "memory_retrieval", "memory_wait_ingestion", "memory_eviction"
+            label = event[:type].sub("memory_", "").tr("_", " ")
+            "\u{1F9E0} #{label}: #{event[:elapsed_ms]}ms"
+          end
+        end
+
+        # Format tool result preview with multiline support.
+        #
+        # Shows up to 3 lines, truncates long lines, and indicates when content
+        # is truncated. Each line is indented and dimmed.
+        #
+        # @param text [String, nil] tool result text
+        # @param max_lines [Integer] maximum lines to show (default: 3)
+        # @param max_line_length [Integer] maximum length per line (default: 100)
+        # @return [String] formatted multiline string
+        def format_tool_result(text, max_lines: 3, max_line_length: 100)
+          return ANSIColors.dim("  \u{21B3} (empty)") if text.nil? || text.to_s.strip.empty?
+
+          lines = text.to_s.lines.map(&:chomp)
+          truncated_vertically = lines.size > max_lines
+
+          # Take first max_lines
+          display_lines = lines.first(max_lines)
+
+          # Truncate each line horizontally
+          formatted = display_lines.map do |line|
+            truncated_line = if line.length > max_line_length
+              "#{line[0...max_line_length]}\u{2026}"
+            else
+              line
+            end
+            ANSIColors.dim("  \u{21B3} #{truncated_line}")
+          end
+
+          # Add ellipsis indicator if truncated vertically
+          if truncated_vertically
+            remaining = lines.size - max_lines
+            formatted << ANSIColors.dim("  \u{21B3} \u{2026} (#{remaining} more line#{"s" if remaining != 1})")
+          end
+
+          formatted.join("\n")
+        end
+
+        # Truncate text to a maximum length, replacing newlines with return arrows.
+        #
+        # @param text [String, nil] text to truncate
+        # @param max [Integer] maximum length
+        # @return [String] truncated text (may include a trailing ellipsis)
+        def truncate(text, max)
+          return "" if text.nil?
+
+          text = text.to_s.tr("\n", "\u{21B5}")
+          text.length > max ? "#{text[0...max]}\u{2026}" : text
+        end
+
+        # Format tool arguments as a compact key: value string.
+        #
+        # @param args [Hash, nil] tool arguments
+        # @return [String] formatted arguments
+        def format_tool_args(args)
+          return "" if args.nil? || args.empty?
+
+          pairs = args.map do |k, v|
+            val = v.is_a?(String) ? "\"#{truncate(v, 50)}\"" : truncate(v.inspect, 50)
+            "#{k}: #{val}"
+          end
+          truncate(pairs.join(", "), 120)
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/v3/file_completer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module V3
+    # File path completion logic for autocomplete.
+    #
+    # FileCompleter provides methods to extract completion targets from text buffers
+    # and find matching file paths using ripgrep (rg). It has no knowledge of the UI,
+    # keyboard input, or display rendering - it only handles the file matching logic.
+    #
+    # @example Extracting completion word
+    #   buffer = "check @lib/swa"
+    #   cursor = 14  # After 'swa'
+    #   result = FileCompleter.extract_completion_word(buffer, cursor)
+    #   # => ["check ", "@lib/swa", ""]
+    #
+    # @example Finding matches
+    #   matches = FileCompleter.find_matches("@lib/swa", max: 5)
+    #   # => ["@lib/swarm_sdk/", "@lib/swarm_cli/", ...]
+    class FileCompleter
+      class << self
+        # Extract the word at cursor position that should trigger completion.
+        #
+        # Searches backward from cursor to find the nearest @ symbol, then extracts
+        # from that @ to the cursor position. Returns nil if no @ is found before cursor.
+        #
+        # @param buffer [String] the full text buffer
+        # @param cursor [Integer] the cursor position (0-based index)
+        #
+        # @return [Array<String>, nil] [pre, target, post] or nil if no @ found
+        #   - pre: text before the @
+        #   - target: the @ and characters up to cursor
+        #   - post: text after cursor
+        #
+        # @example Cursor at end of word
+        #   extract_completion_word("check @README.md", 16)
+        #   # => ["check ", "@README.md", ""]
+        #
+        # @example Cursor in middle of word
+        #   extract_completion_word("check @README.md", 10)
+        #   # => ["check ", "@READ", "ME.md"]
+        #
+        # @example No @ before cursor
+        #   extract_completion_word("check file.txt", 10)
+        #   # => nil
+        def extract_completion_word(buffer, cursor)
+          # Find @ symbol before cursor
+          before_cursor = buffer[0...cursor]
+          at_index = before_cursor.rindex("@")
+          return unless at_index
+
+          # Extract target from @ to cursor
+          target_start = at_index
+          target_end = cursor
+
+          # Find end of word after cursor (next space or end of buffer)
+          target_end += 1 while target_end < buffer.length && buffer[target_end] !~ /\s/
+
+          pre = buffer[0...target_start]
+          target = buffer[target_start...cursor]
+          post = buffer[cursor...target_end] || ""
+
+          [pre, target, post]
+        end
+
+        # Find matching files for a query (with @ prefix).
+        #
+        # Uses ripgrep (rg) for fast file searching with fuzzy case-insensitive matching.
+        # Falls back to empty array if rg is not available or fails.
+        #
+        # @param target [String] the search target (must start with @)
+        # @param max [Integer] maximum number of results to return
+        #
+        # @return [Array<String>] array of completion strings (with @ prefix)
+        #
+        # @example Empty query shows current directory
+        #   find_matches("@", max: 5)
+        #   # => ["@README.md", "@Gemfile", "@lib/", "@test/", "@bin/"]
+        #
+        # @example Fuzzy matching
+        #   find_matches("@lib/swa", max: 5)
+        #   # => ["@lib/swarm_sdk/", "@lib/swarm_cli/", ...]
+        #
+        # @note Requires ripgrep (rg) to be installed. Returns [] if not available.
+        def find_matches(target, max: 5)
+          return [] unless target.start_with?("@")
+
+          query = target[1..] # Strip @
+
+          # Empty query -> show current directory contents (non-hidden)
+          if query.empty?
+            matches = %x(rg --files --max-count=#{max} 2>/dev/null).split("\n")
+            return matches.first(max).map { |p| "@#{p}" }
+          end
+
+          # Use rg --files with grep for fuzzy matching
+          # Get more results than requested so we can sort by quality
+          escaped_query = Regexp.escape(query)
+          matches = %x(rg --files 2>/dev/null | rg -i '#{escaped_query}' --max-count=#{max * 3}).split("\n")
+
+          # Sort by match quality (exact matches first, then by relevance)
+          sorted = matches.sort_by { |path| -score_match(path, query) }
+          sorted.first(max).map { |p| "@#{p}" }
+        rescue StandardError => _e
+          # Fallback to empty if rg fails
+          []
+        end
+
+        # Score a match based on quality (higher = better).
+        # Prioritizes exact matches, then start-of-filename matches,
+        # then shorter/shallower paths.
+        #
+        # @param path [String] the file path
+        # @param query [String] the search query (without @)
+        # @return [Integer] match quality score (higher is better)
+        def score_match(path, query)
+          score = 0
+          basename = File.basename(path)
+          query_lower = query.downcase
+          basename_lower = basename.downcase
+
+          # Exact match gets highest priority
+          score += 1000 if basename_lower == query_lower
+
+          # Match at start of filename gets high priority
+          score += 500 if basename_lower.start_with?(query_lower)
+
+          # Prefer shorter filenames (more specific/complete matches)
+          score += (100 - basename.length).clamp(0, 100)
+
+          # Prefer shallower paths (current directory over subdirectories)
+          depth = path.count("/")
+          score -= depth * 20
+
+          # Small bonus for any match (already filtered by rg)
+          score += 10
+
+          score
+        end
+      end
+    end
+  end
+end