swarm_cli 2.1.13 → 3.0.0.alpha2

data/lib/swarm_cli/v3/raw_input_reader.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module V3
+    # Raw terminal input reader with history support.
+    #
+    # Manages raw terminal mode and reads characters in a background Thread,
+    # producing events on a Thread::Queue. The Async scheduler intercepts
+    # Thread#value in {#next_event}, yielding the fiber so the agent task
+    # can run concurrently.
+    #
+    # Events: +[:line, text]+, +[:interrupt]+, +[:eof]+, +[:exit]+
+    #
+    # @note This class directly controls terminal state via +stty+. Always
+    #   call {#stop} or {#restore_terminal} before exiting.
+    class RawInputReader
+      # @param display [Display] the display coordinator for echoing input
+      def initialize(display)
+        @display = display
+        @queue = Thread::Queue.new
+        @history = []
+        @history_index = nil
+        @saved_buffer = nil
+        @original_stty = nil
+        @thread = nil
+        @running = false
+        @at_exit_registered = false
+        @last_ctrl_c = nil
+        @last_escape = nil
+      end
+
+      # Enter raw terminal mode and start the input thread.
+      #
+      # @return [void]
+      def start
+        @original_stty = %x(stty -g 2>/dev/null).chomp
+        system("stty -icanon -echo -isig min 1 2>/dev/null")
+        @running = true
+        @thread = Thread.new { read_loop }
+
+        return if @at_exit_registered
+
+        at_exit { restore_terminal }
+        @at_exit_registered = true
+      end
+
+      # Stop the input thread and restore terminal state.
+      #
+      # @return [void]
+      def stop
+        @running = false
+        @thread&.kill
+        @thread&.join(0.1)
+        @thread = nil
+        restore_terminal
+      end
+
+      # Restore terminal to its original state (idempotent).
+      #
+      # @return [void]
+      def restore_terminal
+        return unless @original_stty && !@original_stty.empty?
+
+        system("stty #{@original_stty} 2>/dev/null")
+        @original_stty = nil
+      end
+
+      # Returns the next input event, yielding the Async fiber while waiting.
+      #
+      # Async's scheduler intercepts Thread#value and suspends the fiber,
+      # letting the agent task run while we wait for user input.
+      #
+      # @return [Array] event tuple, e.g. +[:line, "hello"]+
+      def next_event
+        Thread.new { @queue.pop }.value
+      end
+
+      # Load history from a file (one entry per line).
+      #
+      # @param path [String] path to the history file
+      # @return [void]
+      def load_history_file(path)
+        return unless File.exist?(path)
+
+        File.open(path, "r:UTF-8") do |f|
+          f.each_line do |line|
+            line = line.chomp
+            @history << line unless line.empty?
+          end
+        end
+      rescue Errno::ENOENT, Errno::EACCES
+        nil
+      end
+
+      # Save history to a file, keeping the last +max+ entries.
+      #
+      # @param path [String] path to the history file
+      # @param max [Integer] maximum entries to keep
+      # @return [void]
+      def save_history_file(path, max: 1000)
+        FileUtils.mkdir_p(File.dirname(path))
+        lines = @history.last(max)
+        File.open(path, "w", 0o600) { |f| lines.each { |l| f.puts(l) } }
+      rescue Errno::EACCES, Errno::ENOENT
+        nil
+      end
+
+      private
+
+      # Main input loop — runs in a dedicated Thread.
+      def read_loop
+        while @running
+          char = $stdin.getc
+          break unless char
+
+          case char
+          when "\x03" then handle_ctrl_c
+          when "\x04" then @queue << [:eof]
+          when "\x14" # Ctrl+T
+            @queue << [:toggle_autocomplete]
+            reset_ctrl_c
+            reset_escape
+          when "\r", "\n"
+            handle_enter
+            reset_ctrl_c
+            reset_escape
+          when "\x7F", "\b"
+            # Close dropdown if open
+            @display.dropdown_close if @display.dropdown_active?
+            @display.backspace
+            reset_ctrl_c
+            reset_escape
+          when "\t"
+            # Tab navigates down in dropdown, or triggers autocomplete
+            if @display.dropdown_active?
+              @display.dropdown_select_next
+            else
+              @queue << [:tab]
+            end
+            reset_ctrl_c
+            reset_escape
+          when "\e"
+            handle_escape_sequence
+            # Don't reset_ctrl_c here - it would clear the ESC hint we just showed
+          else
+            if char.match?(/[[:print:]]/)
+              @display.type_char(char)
+              @queue << [:char_typed, char]
+              reset_ctrl_c
+              reset_escape
+            end
+          end
+        end
+      rescue IOError
+        @queue << [:eof]
+      end
+
+      # Ctrl-C: first press emits :interrupt, second within 0.5s emits :exit
+      def handle_ctrl_c
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if @last_ctrl_c && (now - @last_ctrl_c) < 0.5
+          @last_ctrl_c = nil
+          @display.clear_hint
+          @queue << [:exit]
+        else
+          @last_ctrl_c = now
+          @display.show_hint("Press Ctrl+C again to quit", duration: 1.5)
+          @queue << [:interrupt]
+        end
+      end
+
+      def reset_ctrl_c
+        @last_ctrl_c = nil
+        @display.clear_hint
+      end
+
+      def reset_escape
+        @last_escape = nil
+        @display.clear_hint
+      end
+
+      # Handle Enter — accept dropdown selection or submit line.
+      def handle_enter
+        return if @display.text_input.blank?
+
+        # If dropdown is active, accept selection without submitting
+        if @display.dropdown_active?
+          @queue << [:dropdown_enter]
+          return
+        end
+
+        line = @display.enter
+        add_history(line) unless line.strip.empty?
+        @queue << [:line, line]
+      end
+
+      # Add a non-empty line to history, avoiding consecutive duplicates
+      def add_history(line)
+        return if line.empty? || @history.last == line
+
+        @history << line
+        @history_index = nil
+        @saved_buffer = nil
+      end
+
+      # Parse escape sequences for arrow keys and Alt+Enter.
+      #
+      # Alt+Enter sends ESC followed by CR/LF — inserts a newline.
+      # Arrow keys send ESC [ A/B — navigates history.
+      # Double ESC within 0.5s clears the input buffer.
+      def handle_escape_sequence
+        # Check if there's more input (arrow keys, Alt+Enter, etc.)
+        if IO.select([$stdin], nil, nil, 0.05)
+          seq = $stdin.getc
+
+          # Alt+Enter: ESC followed by CR or LF — insert newline
+          if seq == "\r" || seq == "\n"
+            @display.type_char("\n")
+            return
+          end
+
+          # If not an arrow key sequence, treat as standalone ESC
+          if seq != "["
+            handle_standalone_escape
+            return
+          end
+
+          return unless IO.select([$stdin], nil, nil, 0.05)
+
+          code = $stdin.getc
+          case code
+          when "A" # Up — dropdown takes priority over history
+            if @display.dropdown_active?
+              @display.dropdown_select_previous
+            else
+              navigate_history(:up) unless @display.text_input.multiline? && @display.move_up
+            end
+          when "B" # Down — dropdown takes priority over history
+            if @display.dropdown_active?
+              @display.dropdown_select_next
+            else
+              navigate_history(:down) unless @display.text_input.multiline? && @display.move_down
+            end
+          when "C" then @display.move_right
+          when "D" then @display.move_left
+          when "Z"
+            # Shift-Tab: ESC [ Z - currently unused (reserved for future)
+            @queue << [:shift_tab]
+          end
+        else
+          # Standalone ESC — no follow-up input
+          handle_standalone_escape
+        end
+      end
+
+      def handle_standalone_escape
+        # Close dropdown on ESC
+        if @display.dropdown_active?
+          @display.dropdown_close
+          @last_escape = nil
+          return
+        end
+
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if @last_escape && (now - @last_escape) < 0.5
+          @last_escape = nil
+          @display.clear_input
+        else
+          @last_escape = now
+          @display.show_hint("Press ESC again to clear input")
+        end
+      end
+
+      # Navigate through command history with Up/Down arrows
+      def navigate_history(direction)
+        case direction
+        when :up
+          if @history_index.nil?
+            return if @history.empty?
+
+            @saved_buffer = @display.current_buffer
+            @history_index = @history.size - 1
+          elsif @history_index > 0
+            @history_index -= 1
+          else
+            return
+          end
+          @display.replace_buffer(@history[@history_index])
+        when :down
+          return if @history_index.nil?
+
+          if @history_index < @history.size - 1
+            @history_index += 1
+            @display.replace_buffer(@history[@history_index])
+          else
+            @display.replace_buffer(@saved_buffer || "")
+            @history_index = nil
+            @saved_buffer = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/v3/reboot_tool.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module V3
+    # Tool that triggers a process reboot with continuation message.
+    #
+    # Writes a signal file scoped to the current PID. The CLI checks for
+    # pending signals after each +agent.ask()+ completes and calls
+    # +Kernel.exec+ to replace the process with a fresh Ruby invocation.
+    #
+    # Signal files are PID-scoped (+signal_<pid>.json+) so multiple CLI
+    # sessions sharing the same agent directory don't interfere.
+    #
+    # @example CLI integration
+    #   RebootTool.session_pid = Process.pid
+    #   SwarmSDK::V3::Tools::Registry.register(:Reboot, RebootTool)
+    class RebootTool < SwarmSDK::V3::Tools::Base
+      class << self
+        # @return [Array<Symbol>] Constructor requirements
+        def creation_requirements
+          [:directory]
+        end
+
+        # PID of the CLI session that owns this tool instance.
+        # Set by the CLI at startup.
+        #
+        # @return [Integer, nil]
+        attr_accessor :session_pid
+
+        # Check if a reboot signal is pending for the given PID.
+        #
+        # @param directory [String] Agent working directory
+        # @param pid [Integer] Process ID to check
+        # @return [Boolean]
+        def signal_pending?(directory, pid)
+          File.exist?(signal_path_for(directory, pid))
+        end
+
+        # Read and delete the signal file, returning the parsed data.
+        #
+        # @param directory [String] Agent working directory
+        # @param pid [Integer] Process ID whose signal to consume
+        # @return [Hash, nil] Signal data or nil if no signal exists
+        def consume_signal(directory, pid)
+          path = signal_path_for(directory, pid)
+          return unless File.exist?(path)
+
+          data = JSON.parse(File.read(path), symbolize_names: true)
+          File.delete(path)
+          data
+        end
+
+        # Compute the signal file path for a given PID.
+        #
+        # @param directory [String] Agent working directory
+        # @param pid [Integer] Process ID
+        # @return [String] Absolute path to the signal file
+        def signal_path_for(directory, pid)
+          File.join(File.expand_path(directory), ".swarm", "reboot", "signal_#{pid}.json")
+        end
+      end
+
+      description <<~DESC
+        Trigger a process reboot to reload source code changes.
+
+        Use this after modifying your own source files (with Edit/Write) to
+        reload the changes. The continuation_message should describe what
+        you were doing and what to do next, since short-term memory is lost
+        on reboot. Be detailed — this message is your only context after restart.
+      DESC
+
+      param :continuation_message,
+        type: "string",
+        desc: "Detailed message describing what to do after reboot. " \
+          "This is your only context — include what you changed, why, and what to do next.",
+        required: true
+
+      param :reason,
+        type: "string",
+        desc: "Brief reason for the reboot (for logging)",
+        required: false
+
+      # @param directory [String] Agent working directory
+      def initialize(directory:)
+        super()
+        @directory = File.expand_path(directory)
+      end
+
+      # @return [String] Tool display name
+      def name
+        "Reboot"
+      end
+
+      # Write a reboot signal file for the CLI to detect.
+      #
+      # @param continuation_message [String] Message to resume with after reboot
+      # @param reason [String, nil] Brief reason for the reboot
+      # @return [String] Confirmation message
+      def execute(continuation_message:, reason: nil)
+        pid = self.class.session_pid
+        return error("session_pid not set — Reboot tool requires CLI integration") unless pid
+
+        if continuation_message.nil? || continuation_message.strip.empty?
+          return validation_error("continuation_message is required")
+        end
+
+        signal = {
+          continuation_message: continuation_message,
+          reason: reason,
+          timestamp: Time.now.iso8601,
+          pid: pid,
+        }
+
+        path = self.class.signal_path_for(@directory, pid)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(signal))
+
+        "Reboot signal written. The process will restart after this response completes. " \
+          "Your continuation message has been saved and will be sent as the first prompt after reboot."
+      end
+    end
+  end
+end

data/lib/swarm_cli/v3/text_input.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module V3
+    # Pure data model for the input prompt line with cursor tracking.
+    #
+    # Manages the prompt text, typing buffer, and cursor position with no
+    # I/O side effects. The {Display} coordinator calls {#render} and
+    # uses {#cursor_position} to place the terminal cursor.
+    #
+    # @example
+    #   input = TextInput.new(prompt_text: "you> ")
+    #   input.type_char("h")
+    #   input.type_char("i")
+    #   input.render  # => "\e[32myou> \e[0mhi"
+    #   input.submit  # => "hi"
+    class TextInput
+      # @return [String] current buffer contents
+      attr_reader :buffer
+
+      # @return [Integer] cursor position in the buffer (0 = before first char)
+      attr_reader :cursor
+
+      # @return [Integer] visible length of the prompt (without ANSI codes)
+      attr_reader :prompt_visible_length
+
+      # @param prompt_text [String] visible prompt label (e.g. "you> ")
+      def initialize(prompt_text: "you> ")
+        @prompt_text = prompt_text
+        @prompt_str = ANSIColors.green(prompt_text)
+        @prompt_visible_length = prompt_text.length
+        @buffer = +""
+        @cursor = 0
+      end
+
+      # Insert a character at the cursor position.
+      #
+      # @param char [String] single character to insert
+      # @return [void]
+      def type_char(char)
+        @buffer.insert(@cursor, char)
+        @cursor += char.length
+      end
+
+      # Delete the character before the cursor.
+      #
+      # @return [void]
+      def backspace
+        return if @cursor.zero?
+
+        @buffer.slice!(@cursor - 1)
+        @cursor -= 1
+      end
+
+      # Return the buffer contents and clear it.
+      #
+      # @return [String] the text that was in the buffer
+      def submit
+        text = @buffer.dup
+        @buffer = +""
+        @cursor = 0
+        text
+      end
+
+      # Replace the entire buffer and move cursor to end.
+      #
+      # @param text [String, nil] replacement text
+      # @return [void]
+      def replace(text)
+        @buffer = +(text || "")
+        @cursor = @buffer.length
+      end
+
+      # Whether the buffer is empty or only whitespace.
+      #
+      # @return [Boolean]
+      def blank?
+        @buffer.strip.empty?
+      end
+
+      # Whether the buffer contains newlines.
+      #
+      # @return [Boolean]
+      def multiline?
+        @buffer.include?("\n")
+      end
+
+      # Move cursor one position left.
+      #
+      # @return [void]
+      def move_left
+        @cursor -= 1 if @cursor > 0
+      end
+
+      # Move cursor one position right.
+      #
+      # @return [void]
+      def move_right
+        @cursor += 1 if @cursor < @buffer.length
+      end
+
+      # Move cursor up one line (multiline only).
+      #
+      # @return [void]
+      def move_up
+        row, col = cursor_row_col
+        return if row.zero?
+
+        target_line = buffer_lines[row - 1]
+
+        # Calculate target column accounting for prompt on line 0
+        if row == 1
+          # Moving from line 1 to line 0 (which has the prompt)
+          # Visual columns should align, so subtract prompt length
+          target_col = [col - @prompt_visible_length, 0].max
+          target_col = [target_col, target_line.length].min
+        else
+          # Moving between lines that don't have the prompt
+          target_col = [col, target_line.length].min
+        end
+
+        @cursor = line_start_offset(row - 1) + target_col
+      end
+
+      # Move cursor down one line (multiline only).
+      #
+      # @return [void]
+      def move_down
+        row, col = cursor_row_col
+        lines = buffer_lines
+        return if row >= lines.size - 1
+
+        target_line = lines[row + 1]
+
+        # Calculate target column accounting for prompt on line 0
+        if row.zero?
+          # Moving from line 0 (which has the prompt) to line 1
+          # Visual columns should align, so add prompt length
+          target_col = col + @prompt_visible_length
+          target_col = [target_col, target_line.length].min
+        else
+          # Moving between lines that don't have the prompt
+          target_col = [col, target_line.length].min
+        end
+
+        @cursor = line_start_offset(row + 1) + target_col
+      end
+
+      # Render the full prompt line (prompt string + buffer).
+      #
+      # @return [String] the rendered prompt line with ANSI styling
+      def render
+        "#{@prompt_str}#{@buffer}"
+      end
+
+      # Calculate cursor position as terminal row/column offsets from
+      # the start of the prompt, accounting for line wrapping.
+      #
+      # @param width [Integer] terminal width in columns
+      # @return [Array(Integer, Integer)] [rows_from_start, column]
+      def cursor_position(width)
+        return [0, @prompt_visible_length + @cursor] if width <= 0
+
+        text_before = @buffer[0, @cursor] || ""
+        lines = text_before.split("\n", -1)
+
+        row = 0
+        lines.each_with_index do |line, idx|
+          visible = (idx.zero? ? @prompt_visible_length : 0) + line.length
+          row += visible / width
+        end
+        row += lines.size - 1 if lines.size > 1
+
+        last_line = lines.last || ""
+        last_prefix = lines.size <= 1 ? @prompt_visible_length : 0
+        col = (last_prefix + last_line.length) % width
+
+        [row, col]
+      end
+
+      # Calculate extra lines from wrapping and explicit newlines.
+      #
+      # @param width [Integer] terminal width in columns
+      # @return [Integer] number of extra lines (0 if no wrapping)
+      def wrapped_lines(width)
+        return 0 if width <= 0
+
+        lines = buffer_lines
+        total = 0
+
+        lines.each_with_index do |line, idx|
+          visible = (idx.zero? ? @prompt_visible_length : 0) + line.length
+          total += visible > 0 ? (visible - 1) / width : 0
+        end
+
+        total += lines.size - 1 if lines.size > 1
+        total
+      end
+
+      private
+
+      # Split buffer into lines.
+      #
+      # @return [Array<String>]
+      def buffer_lines
+        @buffer.split("\n", -1)
+      end
+
+      # Row and column of cursor within the buffer lines (not terminal).
+      #
+      # @return [Array(Integer, Integer)] [line_index, column_in_line]
+      def cursor_row_col
+        before = @buffer[0, @cursor] || ""
+        lines = before.split("\n", -1)
+        return [0, 0] if lines.empty?
+
+        [lines.size - 1, lines.last.length]
+      end
+
+      # Byte offset in @buffer where a given line starts.
+      #
+      # @param line_index [Integer]
+      # @return [Integer]
+      def line_start_offset(line_index)
+        offset = 0
+        @buffer.split("\n", -1).each_with_index do |line, idx|
+          return offset if idx == line_index
+
+          offset += line.length + 1 # +1 for the \n
+        end
+        offset
+      end
+    end
+  end
+end

data/lib/swarm_cli/v3.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# V3 CLI Entry Point
+#
+# This file provides a standalone entry point for SwarmCLI V3 that doesn't
+# depend on the V2 CLI code. It loads only the minimal dependencies needed
+# for the V3 interactive CLI.
+#
+# @example
+#   require "swarm_cli/v3"
+#   SwarmCLI::V3::CLI.start(ARGV)
+
+require "io/console"
+require "optparse"
+
+require "tty/markdown"
+
+require "swarm_sdk/v3"
+
+require "zeitwerk"
+
+module SwarmCLI
+  class Error < StandardError; end
+
+  # V3 is the next-generation CLI for SwarmSDK V3 agents.
+  #
+  # Features:
+  # - Interactive REPL with always-available input
+  # - Single-prompt execution mode
+  # - Memory maintenance commands
+  # - Minimal dependencies (custom ANSI styling, raw input handling)
+  module V3
+  end
+end
+
+# V3 CLI Zeitwerk setup
+v3_cli_dir = File.join(__dir__, "v3")
+already_managed = false
+Zeitwerk::Registry.loaders.each do |loader|
+  loader.dirs.each { |dir| already_managed = true if v3_cli_dir.start_with?(dir) }
+end
+
+unless already_managed
+  v3_cli_loader = Zeitwerk::Loader.new
+  v3_cli_loader.tag = "swarm_cli_v3"
+  v3_cli_loader.push_dir(v3_cli_dir, namespace: SwarmCLI::V3)
+  v3_cli_loader.inflector.inflect(
+    "ansi_colors" => "ANSIColors",
+    "cli" => "CLI",
+  )
+  v3_cli_loader.setup
+end