mui 0.2.0 → 0.4.0

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

data/lib/mui/key_handler/operators/paste_operator.rb

@@ -37,6 +37,7 @@ module Mui
         private
 
         def paste_line_after(name: nil)
+          undo_manager&.begin_group
           text = @register.get(name:)
           lines = text.split("\n", -1)
           lines.reverse_each do |line|
@@ -44,15 +45,18 @@ module Mui
           end
           self.cursor_row = cursor_row + 1
           self.cursor_col = 0
+          undo_manager&.end_group
         end
 
         def paste_line_before(name: nil)
+          undo_manager&.begin_group
           text = @register.get(name:)
           lines = text.split("\n", -1)
           lines.reverse_each do |line|
             @buffer.insert_line(cursor_row, line)
           end
           self.cursor_col = 0
+          undo_manager&.end_group
         end
 
         def paste_char_after(name: nil)
@@ -63,7 +67,7 @@ module Mui
           if text.include?("\n")
             paste_multiline_char(text, line, insert_col)
           else
-            @buffer.lines[cursor_row] = line[0...insert_col].to_s + text + line[insert_col..].to_s
+            @buffer.replace_line(cursor_row, line[0...insert_col].to_s + text + line[insert_col..].to_s)
             self.cursor_col = insert_col + text.length - 1
             @window.clamp_cursor_to_line(@buffer)
           end
@@ -76,19 +80,20 @@ module Mui
           if text.include?("\n")
             paste_multiline_char(text, line, cursor_col)
           else
-            @buffer.lines[cursor_row] = line[0...cursor_col].to_s + text + line[cursor_col..].to_s
+            @buffer.replace_line(cursor_row, line[0...cursor_col].to_s + text + line[cursor_col..].to_s)
             self.cursor_col = cursor_col + text.length - 1
             @window.clamp_cursor_to_line(@buffer)
           end
         end
 
         def paste_multiline_char(text, line, insert_col)
+          undo_manager&.begin_group
           lines = text.split("\n", -1)
           before = line[0...insert_col].to_s
           after = line[insert_col..].to_s
 
           # First line: before + first part of pasted text
-          @buffer.lines[cursor_row] = before + lines.first
+          @buffer.replace_line(cursor_row, before + lines.first)
 
           # Middle lines: insert as new lines
           lines[1...-1].each_with_index do |pasted_line, idx|
@@ -106,6 +111,7 @@ module Mui
           self.cursor_col = lines.last.length - 1
           self.cursor_col = 0 if cursor_col.negative?
           @window.clamp_cursor_to_line(@buffer)
+          undo_manager&.end_group
         end
       end
     end

data/lib/mui/key_handler/search_mode.rb

@@ -23,6 +23,10 @@ module Mui
       end
 
       def handle(key)
+        # Check plugin keymaps first
+        plugin_result = check_plugin_keymap(key, :search)
+        return plugin_result if plugin_result
+
         case key
         when KeyCode::ESCAPE
           handle_escape
@@ -136,19 +140,19 @@ module Mui
 
         direction = @search_input.prompt == "/" ? :forward : :backward
         @search_state.set_pattern(pattern, direction)
-        @search_state.find_all_matches(buffer)
 
         # Move cursor to first match from original position
-        return if @search_state.matches.empty?
+        matches = @search_state.find_all_matches(buffer)
+        return if matches.empty?
 
         # Use original position if set, otherwise use current cursor position
         search_row = @original_cursor_row || cursor_row
         search_col = @original_cursor_col || cursor_col
 
         match = if direction == :forward
-                  @search_state.find_next(search_row, search_col)
+                  @search_state.find_next(search_row, search_col, buffer:)
                 else
-                  @search_state.find_previous(search_row, search_col)
+                  @search_state.find_previous(search_row, search_col, buffer:)
                 end
 
         return unless match
@@ -163,12 +167,11 @@ module Mui
 
         direction = @search_input.prompt == "/" ? :forward : :backward
         @search_state.set_pattern(pattern, direction)
-        @search_state.find_all_matches(@buffer)
 
         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

data/lib/mui/key_handler/visual_mode.rb

@@ -18,6 +18,12 @@ module Mui
       end
 
       def handle(key)
+        # Check plugin keymaps first (only when no pending motion)
+        unless @pending_motion
+          plugin_result = check_plugin_keymap(key, :visual)
+          return plugin_result if plugin_result
+        end
+
         if @pending_motion
           handle_pending_motion(key)
         else
@@ -120,7 +126,7 @@ module Mui
         if @selection.line_mode
           change_lines(range)
         else
-          @undo_manager&.begin_group
+          undo_manager&.begin_group
           change_range(range)
         end
         @pending_register = nil
@@ -154,16 +160,15 @@ module Mui
         # Escape special regex characters for literal search
         escaped_pattern = Regexp.escape(text)
 
-        # Set search state and find matches
+        # Set search state
         search_state = @mode_manager.search_state
         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
@@ -207,7 +212,7 @@ module Mui
       def change_lines(range)
         lines = (range[:start_row]..range[:end_row]).map { |r| buffer.line(r) }
         @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
-        @undo_manager&.begin_group
+        undo_manager&.begin_group
         (range[:end_row] - range[:start_row] + 1).times do
           buffer.delete_line(range[:start_row])
         end
@@ -229,11 +234,11 @@ module Mui
       def delete_lines(range)
         lines = (range[:start_row]..range[:end_row]).map { |r| buffer.line(r) }
         @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
-        @undo_manager&.begin_group unless @undo_manager&.in_group?
+        undo_manager&.begin_group unless undo_manager&.in_group?
         (range[:end_row] - range[:start_row] + 1).times do
           buffer.delete_line(range[:start_row])
         end
-        @undo_manager&.end_group
+        undo_manager&.end_group
         self.cursor_row = [range[:start_row], buffer.line_count - 1].min
         self.cursor_col = 0
         window.clamp_cursor_to_line(buffer)
@@ -268,7 +273,7 @@ module Mui
       def indent_lines(start_row, end_row, direction)
         indent_string = build_indent_string
 
-        @undo_manager&.begin_group unless @undo_manager&.in_group?
+        undo_manager&.begin_group unless undo_manager&.in_group?
 
         (start_row..end_row).each do |row|
           if direction == :right
@@ -278,7 +283,7 @@ module Mui
           end
         end
 
-        @undo_manager&.end_group
+        undo_manager&.end_group
       end
 
       def build_indent_string