mui 0.2.0 → 0.3.0

data/lib/mui/editor.rb

@@ -4,7 +4,7 @@ module Mui
   # Main editor class that coordinates all components
   class Editor
     attr_reader :tab_manager, :undo_manager, :autocmd, :command_registry, :job_manager, :color_scheme, :floating_window,
-                :insert_completion_state
+                :insert_completion_state, :key_sequence_handler
     attr_accessor :message, :running
 
     def initialize(file_path = nil, adapter: TerminalAdapter::Curses.new, load_config: true)
@@ -46,12 +46,17 @@ module Mui
       # Load plugin autocmds
       load_plugin_autocmds
 
+      # Initialize key sequence handler for multi-key mappings
+      @key_sequence_handler = KeySequenceHandler.new(Mui.config)
+      @key_sequence_handler.rebuild_keymaps
+
       @mode_manager = ModeManager.new(
         window: @tab_manager,
         buffer: @buffer,
         command_line: @command_line,
         undo_manager: @undo_manager,
-        editor: self
+        editor: self,
+        key_sequence_handler: @key_sequence_handler
       )
 
       # Trigger BufEnter event
@@ -85,6 +90,7 @@ module Mui
     def run
       while @running
         process_job_results
+        check_key_sequence_timeout
         update_window_size
         render
         key = @input.read_nonblock
@@ -108,6 +114,42 @@ module Mui
       window_manager.split_horizontal(scratch_buffer)
     end
 
+    # Update existing scratch buffer or create new one
+    def update_or_create_scratch_buffer(name, content)
+      existing = find_scratch_buffer(name)
+
+      if existing
+        existing.content = content
+        focus_buffer(existing)
+      else
+        open_scratch_buffer(name, content)
+      end
+    end
+
+    # Find a scratch buffer by name across all tabs and windows
+    def find_scratch_buffer(name)
+      @tab_manager.tabs.each do |tab|
+        tab.window_manager.windows.each do |win|
+          return win.buffer if win.buffer.name == name && win.buffer.readonly?
+        end
+      end
+      nil
+    end
+
+    # Focus a specific buffer by switching to its window
+    def focus_buffer(target_buffer)
+      @tab_manager.tabs.each_with_index do |tab, tab_index|
+        tab.window_manager.windows.each do |win|
+          next unless win.buffer == target_buffer
+
+          @tab_manager.go_to(tab_index)
+          tab.window_manager.focus_window(win)
+          return true
+        end
+      end
+      false
+    end
+
     # Suspend UI for running external interactive commands (e.g., fzf)
     def suspend_ui
       @adapter.suspend
@@ -315,5 +357,39 @@ module Mui
     def process_job_results
       @job_manager.poll
     end
+
+    def check_key_sequence_timeout
+      return unless @key_sequence_handler.pending?
+
+      mode_symbol = mode_to_symbol(@mode_manager.mode)
+      result = @key_sequence_handler.check_timeout(mode_symbol)
+
+      return unless result
+
+      type, data = result
+      case type
+      when KeySequenceHandler::RESULT_HANDLED
+        execute_keymap_handler(data)
+      when KeySequenceHandler::RESULT_PASSTHROUGH
+        # Re-process the passthrough key
+        handle_key(data) if data
+      end
+    end
+
+    def mode_to_symbol(mode)
+      case mode
+      when Mode::NORMAL then :normal
+      when Mode::INSERT then :insert
+      when Mode::VISUAL, Mode::VISUAL_LINE then :visual
+      when Mode::COMMAND then :command
+      when Mode::SEARCH_FORWARD, Mode::SEARCH_BACKWARD then :search
+      else :normal
+      end
+    end
+
+    def execute_keymap_handler(handler)
+      context = CommandContext.new(editor: self, buffer:, window:)
+      handler.call(context)
+    end
   end
 end

data/lib/mui/handler_result.rb

@@ -6,10 +6,11 @@ module Mui
     class Base
       attr_reader :mode, :message
 
-      def initialize(mode: nil, message: nil, quit: false)
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false)
         @mode = mode
         @message = message
         @quit = quit
+        @pending_sequence = pending_sequence
         freeze
       end
 
@@ -17,6 +18,11 @@ module Mui
         @quit
       end
 
+      # True when waiting for more keys in a multi-key sequence
+      def pending_sequence?
+        @pending_sequence
+      end
+
       def start_selection?
         false
       end
@@ -36,11 +42,11 @@ module Mui
 
     # Result for NormalMode - handles visual mode start
     class NormalModeResult < Base
-      def initialize(mode: nil, message: nil, quit: false, start_selection: false, line_mode: false, group_started: false)
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false, start_selection: false, line_mode: false, group_started: false)
         @start_selection = start_selection
         @line_mode = line_mode
         @group_started = group_started
-        super(mode:, message:, quit:)
+        super(mode:, message:, quit:, pending_sequence:)
       end
 
       def start_selection?
@@ -58,11 +64,11 @@ module Mui
 
     # Result for VisualMode - handles selection clear and line mode toggle
     class VisualModeResult < Base
-      def initialize(mode: nil, message: nil, quit: false, clear_selection: false, toggle_line_mode: false, group_started: false)
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false, clear_selection: false, toggle_line_mode: false, group_started: false)
         @clear_selection = clear_selection
         @toggle_line_mode = toggle_line_mode
         @group_started = group_started
-        super(mode:, message:, quit:)
+        super(mode:, message:, quit:, pending_sequence:)
       end
 
       def clear_selection?
@@ -88,9 +94,9 @@ module Mui
 
     # Result for SearchMode - handles search execution
     class SearchModeResult < Base
-      def initialize(mode: nil, message: nil, quit: false, cancelled: false)
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false, cancelled: false)
         @cancelled = cancelled
-        super(mode:, message:, quit:)
+        super(mode:, message:, quit:, pending_sequence:)
       end
 
       def cancelled?

data/lib/mui/highlighters/search_highlighter.rb

@@ -5,9 +5,10 @@ module Mui
     class SearchHighlighter < Base
       def highlights_for(row, _line, options = {})
         search_state = options[:search_state]
+        buffer = options[:buffer]
         return [] unless search_state&.has_pattern?
 
-        matches = search_state.matches_for_row(row)
+        matches = search_state.matches_for_row(row, buffer:)
         matches.map do |match|
           Highlight.new(
             start_col: match[:col],

data/lib/mui/highlighters/syntax_highlighter.rb

@@ -19,7 +19,9 @@ module Mui
         instance_variable: :syntax_instance_variable,
         global_variable: :syntax_global_variable,
         method_call: :syntax_method_call,
-        type: :syntax_type
+        type: :syntax_type,
+        macro: :syntax_keyword,    # Rust macros (println!, vec!, etc.)
+        regex: :syntax_string      # JavaScript/TypeScript regex literals
       }.freeze
 
       def initialize(color_scheme, buffer: nil)

data/lib/mui/key_handler/base.rb

@@ -27,13 +27,100 @@ module Mui
         @mode_manager&.editor
       end
 
+      # Returns the current buffer's undo_manager for dynamic access
+      # This ensures undo/redo works correctly when buffer changes (e.g., via :e)
+      def undo_manager
+        buffer&.undo_manager
+      end
+
+      # Access to key sequence handler for multi-key mappings
+      def key_sequence_handler
+        @mode_manager&.key_sequence_handler
+      end
+
       # Handle a key input
       def handle(_key)
         raise MethodNotOverriddenError, "Subclasses must orverride #handle"
       end
 
+      # Check plugin keymap with multi-key sequence support
+      # @param key [Integer, String] Raw key input
+      # @param mode_symbol [Symbol] Mode symbol (:normal, :insert, :visual, :command)
+      # @return [HandlerResult, nil] Result if handled or pending, nil to continue with built-in
+      def check_plugin_keymap(key, mode_symbol)
+        return nil unless key_sequence_handler
+
+        type, data = key_sequence_handler.process(key, mode_symbol)
+
+        case type
+        when KeySequenceHandler::RESULT_HANDLED
+          execute_plugin_handler(data, mode_symbol)
+        when KeySequenceHandler::RESULT_PENDING
+          # Return a result that tells the handler to wait
+          # Use base class directly since subclasses may not support pending_sequence
+          HandlerResult::Base.new(pending_sequence: true)
+        when KeySequenceHandler::RESULT_PASSTHROUGH
+          # Check for single-key keymap (backward compatibility)
+          check_single_key_keymap(data, mode_symbol)
+        end
+      end
+
       private
 
+      # Check single-key keymap for backward compatibility
+      def check_single_key_keymap(key, mode_symbol)
+        key_str = convert_key_to_string(key)
+        return nil unless key_str
+
+        plugin_handler = Mui.config.keymaps[mode_symbol]&.[](key_str)
+        return nil unless plugin_handler
+
+        execute_plugin_handler(plugin_handler, mode_symbol)
+      end
+
+      # Execute a plugin handler and wrap result
+      def execute_plugin_handler(handler, mode_symbol)
+        return nil unless @mode_manager&.editor
+
+        context = CommandContext.new(
+          editor: @mode_manager.editor,
+          buffer:,
+          window:
+        )
+        handler_result = handler.call(context)
+
+        return nil unless handler_result
+
+        wrap_handler_result(handler_result, mode_symbol)
+      end
+
+      # Wrap handler result in appropriate type
+      def wrap_handler_result(handler_result, _mode_symbol)
+        return handler_result if handler_result.is_a?(HandlerResult::Base)
+
+        result
+      end
+
+      # Convert key to string for keymap lookup
+      def convert_key_to_string(key)
+        return key if key.is_a?(String)
+
+        case key
+        when KeyCode::ENTER_CR, KeyCode::ENTER_LF
+          "\r"
+        when KeyCode::ESCAPE
+          "\e"
+        when KeyCode::TAB
+          "\t"
+        when KeyCode::BACKSPACE
+          "\x7f"
+        else
+          key.chr
+        end
+      rescue RangeError
+        nil
+      end
+
       def cursor_row
         window.cursor_row
       end

data/lib/mui/key_handler/command_mode.rb

@@ -15,6 +15,10 @@ module Mui
       end
 
       def handle(key)
+        # Check plugin keymaps first
+        plugin_result = check_plugin_keymap(key, :command)
+        return plugin_result if plugin_result
+
         case key
         when KeyCode::ESCAPE
           handle_escape
@@ -30,6 +34,10 @@ module Mui
           handle_cursor_left
         when Curses::KEY_RIGHT
           handle_cursor_right
+        when Curses::KEY_UP
+          handle_history_up
+        when Curses::KEY_DOWN
+          handle_history_down
         else
           handle_character_input(key)
         end
@@ -82,6 +90,18 @@ module Mui
         result
       end
 
+      def handle_history_up
+        @completion_state.reset
+        @command_line.history_previous
+        result
+      end
+
+      def handle_history_down
+        @completion_state.reset
+        @command_line.history_next
+        result
+      end
+
       def update_completion
         context = @command_line.completion_context
         unless context
@@ -176,6 +196,10 @@ module Mui
           handle_tab_move(command_result[:position])
         when :goto_line
           handle_goto_line(command_result[:line_number])
+        when :shell_command
+          handle_shell_command(command_result[:command])
+        when :shell_command_error
+          result(message: command_result[:message])
         when :unknown
           # Check plugin commands before reporting unknown
           plugin_result = try_plugin_command(command_result[:command])
@@ -264,7 +288,9 @@ module Mui
 
       def open_new_buffer(path)
         new_buffer = create_buffer_from_path(path)
+        new_buffer.undo_manager = UndoManager.new
         window.buffer = new_buffer
+
         result(message: "\"#{path}\" opened")
       rescue SystemCallError => e
         result(message: "Error: #{e.message}")
@@ -303,6 +329,7 @@ module Mui
       def handle_split_horizontal(path = nil)
         with_window_manager do |wm|
           buffer = path ? create_buffer_from_path(path) : nil
+          buffer&.undo_manager = UndoManager.new
           wm.split_horizontal(buffer)
           result
         end
@@ -311,6 +338,7 @@ module Mui
       def handle_split_vertical(path = nil)
         with_window_manager do |wm|
           buffer = path ? create_buffer_from_path(path) : nil
+          buffer&.undo_manager = UndoManager.new
           wm.split_vertical(buffer)
           result
         end
@@ -352,6 +380,7 @@ module Mui
         with_tab_manager do |tm|
           new_tab = tm.add
           buffer = path ? create_buffer_from_path(path) : Buffer.new
+          buffer.undo_manager = UndoManager.new
           new_tab.window_manager.add_window(buffer)
           result
         end
@@ -424,6 +453,45 @@ module Mui
         result
       end
 
+      def handle_shell_command(cmd)
+        return result(message: "Shell commands not available") unless @mode_manager&.editor
+
+        context = CommandContext.new(
+          editor: @mode_manager.editor,
+          buffer:,
+          window:
+        )
+
+        context.run_shell_command(cmd, on_complete: lambda { |job|
+          display_shell_result(job, cmd)
+        })
+
+        result(message: "Running: #{cmd}")
+      end
+
+      def display_shell_result(job, cmd)
+        return unless @mode_manager&.editor
+
+        output = build_shell_output(job, cmd)
+        @mode_manager.editor.update_or_create_scratch_buffer("[Shell Output]", output)
+      end
+
+      def build_shell_output(job, cmd)
+        res = job.result
+        lines = ["$ #{cmd}", ""]
+
+        lines << res[:stdout].chomp unless res[:stdout].empty?
+
+        unless res[:stderr].empty?
+          lines << "[stderr]"
+          lines << res[:stderr].chomp
+        end
+
+        lines << "" << "[Exit status: #{res[:exit_status]}]" unless res[:success]
+
+        lines.join("\n")
+      end
+
       def create_buffer_from_path(path)
         new_buffer = Buffer.new
         new_buffer.load(path)

data/lib/mui/key_handler/insert_mode.rb

@@ -8,7 +8,8 @@ module Mui
         super(mode_manager, buffer)
         @undo_manager = undo_manager
         # Start undo group unless already started (e.g., by change operator)
-        @undo_manager&.begin_group unless group_started
+        # Use dynamic undo_manager to support buffer changes via :e/:sp/:vs/:tabnew
+        self.undo_manager&.begin_group unless group_started
         # Build word cache for fast completion (use active window's buffer)
         @word_cache = BufferWordCache.new(self.buffer)
       end
@@ -44,51 +45,13 @@ module Mui
         end
       end
 
-      def check_plugin_keymap(key, mode_symbol)
-        return nil unless @mode_manager&.editor
-
-        key_str = convert_key_to_string(key)
-        return nil unless key_str
-
-        plugin_handler = Mui.config.keymaps[mode_symbol]&.[](key_str)
-        return nil unless plugin_handler
-
-        context = CommandContext.new(
-          editor: @mode_manager.editor,
-          buffer:,
-          window:
-        )
-        handler_result = plugin_handler.call(context)
-
-        # If handler returns nil/false, let built-in handle it
-        return nil unless handler_result
-
-        # Return a valid result to indicate the key was handled
-        handler_result.is_a?(HandlerResult::InsertModeResult) ? handler_result : result
-      end
-
-      def convert_key_to_string(key)
-        return key if key.is_a?(String)
-
-        # Handle special Curses keys
-        case key
-        when KeyCode::ENTER_CR, KeyCode::ENTER_LF, Curses::KEY_ENTER
-          "\r"
-        else
-          key.chr
-        end
-      rescue RangeError
-        # Key code out of char range (e.g., special function keys)
-        nil
-      end
-
       private
 
       def handle_escape
         # Cancel completion if active
         editor.insert_completion_state.reset if completion_active?
 
-        @undo_manager&.end_group
+        undo_manager&.end_group
         # Remove trailing whitespace from current line if it's whitespace-only (Vim behavior)
         stripped = strip_trailing_whitespace_if_empty_line
         # Move cursor back one position unless we just stripped whitespace (cursor already at 0)
@@ -107,11 +70,13 @@ module Mui
       end
 
       def handle_move_left
+        reset_insert_completion_state
         self.cursor_col = cursor_col - 1 if cursor_col.positive?
         result
       end
 
       def handle_move_right
+        reset_insert_completion_state
         self.cursor_col = cursor_col + 1 if cursor_col < current_line_length
         result
       end
@@ -134,7 +99,7 @@ module Mui
           update_completion_list if completion_active?
         elsif cursor_row.positive?
           join_with_previous_line
-          editor.insert_completion_state.reset if completion_active?
+          reset_insert_completion_state
         end
         result
       end
@@ -346,6 +311,10 @@ module Mui
         end
       end
 
+      def reset_insert_completion_state
+        editor.insert_completion_state.reset if completion_active?
+      end
+
       def result(mode: nil, message: nil, quit: false)
         HandlerResult::InsertModeResult.new(mode:, message:, quit:)
       end

data/lib/mui/key_handler/normal_mode.rb

@@ -21,8 +21,9 @@ module Mui
         # Sync operators with current buffer/window (may have changed via tab switch)
         sync_operators
 
-        # Check plugin keymaps first (only when no pending motion)
-        unless @pending_motion
+        # Check plugin keymaps first
+        # Skip if: has pending motion OR (is builtin key AND no pending sequence)
+        unless @pending_motion || (builtin_operator_key?(key) && !pending_sequence?)
           plugin_result = check_plugin_keymap(key, :normal)
           return plugin_result if plugin_result
         end
@@ -34,49 +35,22 @@ module Mui
         end
       end
 
-      def check_plugin_keymap(key, mode_symbol)
-        return nil unless @mode_manager&.editor
-
-        key_str = convert_key_to_string(key)
-        return nil unless key_str
-
-        plugin_handler = Mui.config.keymaps[mode_symbol]&.[](key_str)
-        return nil unless plugin_handler
-
-        context = CommandContext.new(
-          editor: @mode_manager.editor,
-          buffer:,
-          window:
-        )
-        handler_result = plugin_handler.call(context)
+      # Check if there's a pending multi-key sequence in progress
+      def pending_sequence?
+        key_sequence_handler&.pending?
+      end
 
-        # If handler returns nil/false, let built-in handle it
-        # This allows buffer-specific keymaps to pass through for other buffers
-        return nil unless handler_result
+      # Check if key starts a built-in operator (takes priority over plugins)
+      def builtin_operator_key?(key)
+        char = key_to_char(key)
+        return false unless char
 
-        # Return a valid result to indicate the key was handled
-        handler_result.is_a?(HandlerResult::NormalModeResult) ? handler_result : result
+        # Built-in operators and motions that set pending_motion
+        %w[d c y g f F t T].include?(char) || key == KeyCode::CTRL_W
       end
 
       private
 
-      # Convert key to string for keymap lookup
-      # Handles special keys like Enter that have Curses constants
-      def convert_key_to_string(key)
-        return key if key.is_a?(String)
-
-        # Handle special Curses keys
-        case key
-        when KeyCode::ENTER_CR, KeyCode::ENTER_LF, Curses::KEY_ENTER
-          "\r"
-        else
-          key.chr
-        end
-      rescue RangeError
-        # Key code out of char range (e.g., special function keys)
-        nil
-      end
-
       def initialize_operators
         @operators = {
           delete: Operators::DeleteOperator.new(
@@ -95,7 +69,7 @@ module Mui
       end
 
       def sync_operators
-        @operators.each_value { |op| op.update(buffer:, window:) }
+        @operators.each_value { |op| op.update(buffer:, window:, undo_manager:) }
       end
 
       def handle_normal_key(key)
@@ -298,7 +272,7 @@ module Mui
       end
 
       def handle_open_below
-        @undo_manager&.begin_group
+        undo_manager&.begin_group
         buffer.insert_line(cursor_row + 1)
         self.cursor_row = cursor_row + 1
         self.cursor_col = 0
@@ -306,7 +280,7 @@ module Mui
       end
 
       def handle_open_above
-        @undo_manager&.begin_group
+        undo_manager&.begin_group
         buffer.insert_line(cursor_row)
         self.cursor_col = 0
         result(mode: Mode::INSERT, group_started: true)
@@ -410,7 +384,7 @@ module Mui
 
       # Undo/Redo handlers
       def handle_undo
-        if @undo_manager&.undo(buffer)
+        if undo_manager&.undo(buffer)
           window.clamp_cursor_to_line(buffer)
           result
         else
@@ -419,7 +393,7 @@ module Mui
       end
 
       def handle_redo
-        if @undo_manager&.redo(buffer)
+        if undo_manager&.redo(buffer)
           window.clamp_cursor_to_line(buffer)
           result
         else
@@ -500,9 +474,9 @@ module Mui
         return result(message: "No previous search pattern") unless @search_state&.has_pattern?
 
         match = if @search_state.direction == :forward
-                  @search_state.find_next(cursor_row, cursor_col)
+                  @search_state.find_next(cursor_row, cursor_col, buffer:)
                 else
-                  @search_state.find_previous(cursor_row, cursor_col)
+                  @search_state.find_previous(cursor_row, cursor_col, buffer:)
                 end
 
         if match
@@ -517,9 +491,9 @@ module Mui
         return result(message: "No previous search pattern") unless @search_state&.has_pattern?
 
         match = if @search_state.direction == :forward
-                  @search_state.find_previous(cursor_row, cursor_col)
+                  @search_state.find_previous(cursor_row, cursor_col, buffer:)
                 else
-                  @search_state.find_next(cursor_row, cursor_col)
+                  @search_state.find_next(cursor_row, cursor_col, buffer:)
                 end
 
         if match
@@ -538,13 +512,12 @@ module Mui
         escaped_pattern = "\\b#{Regexp.escape(word)}\\b"
 
         @search_state.set_pattern(escaped_pattern, direction)
-        @search_state.find_all_matches(buffer)
 
         # Find next/previous match from current position
         match = if direction == :forward
-                  @search_state.find_next(cursor_row, cursor_col)
+                  @search_state.find_next(cursor_row, cursor_col, buffer:)
                 else
-                  @search_state.find_previous(cursor_row, cursor_col)
+                  @search_state.find_previous(cursor_row, cursor_col, buffer:)
                 end
 
         if match