mui 0.2.0 → 0.4.0

data/lib/mui/command_history.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages command history with file persistence
+  class CommandHistory
+    MAX_HISTORY = 100
+    HISTORY_FILE = File.expand_path("~/.mui_history")
+
+    attr_reader :history
+
+    def initialize(history_file: HISTORY_FILE)
+      @history_file = history_file
+      @history = []
+      @index = nil
+      @saved_input = nil
+      load_from_file
+    end
+
+    def add(command)
+      return if command.strip.empty?
+
+      @history.delete(command)
+      @history.push(command)
+      @history.shift if @history.size > MAX_HISTORY
+      save_to_file
+    end
+
+    def previous(current_input)
+      return nil if @history.empty?
+
+      if @index.nil?
+        @saved_input = current_input
+        @index = @history.size - 1
+      elsif @index.positive?
+        @index -= 1
+      else
+        return nil
+      end
+
+      @history[@index]
+    end
+
+    def next_entry
+      return nil if @index.nil?
+
+      if @index < @history.size - 1
+        @index += 1
+        @history[@index]
+      else
+        result = @saved_input
+        reset
+        result
+      end
+    end
+
+    def reset
+      @index = nil
+      @saved_input = nil
+    end
+
+    def browsing?
+      !@index.nil?
+    end
+
+    def size
+      @history.size
+    end
+
+    def empty?
+      @history.empty?
+    end
+
+    private
+
+    def load_from_file
+      return unless File.exist?(@history_file)
+
+      @history = File.readlines(@history_file, chomp: true).last(MAX_HISTORY)
+    rescue StandardError
+      @history = []
+    end
+
+    def save_to_file
+      File.write(@history_file, "#{@history.join("\n")}\n")
+    rescue StandardError
+      # Ignore write failures
+    end
+  end
+end

data/lib/mui/command_line.rb

@@ -5,11 +5,12 @@ module Mui
     # Commands that accept file path arguments
     FILE_COMMANDS = %w[e w sp split vs vsplit tabnew tabe tabedit].freeze
 
-    attr_reader :buffer, :cursor_pos
+    attr_reader :buffer, :cursor_pos, :history
 
-    def initialize
+    def initialize(history: CommandHistory.new)
       @buffer = ""
       @cursor_pos = 0
+      @history = history
     end
 
     def input(char)
@@ -27,6 +28,25 @@ module Mui
     def clear
       @buffer = ""
       @cursor_pos = 0
+      @history.reset
+    end
+
+    def history_previous
+      result = @history.previous(@buffer)
+      return false unless result
+
+      @buffer = result.dup
+      @cursor_pos = @buffer.length
+      true
+    end
+
+    def history_next
+      result = @history.next_entry
+      return false unless result
+
+      @buffer = result.dup
+      @cursor_pos = @buffer.length
+      true
     end
 
     def move_cursor_left
@@ -38,6 +58,9 @@ module Mui
     end
 
     def execute
+      command = @buffer.strip
+      @history.add(command) unless command.empty?
+      @history.reset
       result = parse(@buffer)
       @buffer = ""
       @cursor_pos = 0
@@ -127,6 +150,13 @@ module Mui
         { action: :tab_move, position: ::Regexp.last_match(1).to_i }
       when /^(\d+)tabn(?:ext)?/, /^tabn(?:ext)?\s+(\d+)/
         { action: :tab_go, index: ::Regexp.last_match(1).to_i - 1 }
+      when /^!(.*)$/
+        shell_cmd = ::Regexp.last_match(1).strip
+        if shell_cmd.empty?
+          { action: :shell_command_error, message: "E471: Argument required" }
+        else
+          { action: :shell_command, command: shell_cmd }
+        end
       when /^(\d+)$/
         { action: :goto_line, line_number: ::Regexp.last_match(1).to_i }
       else

data/lib/mui/command_registry.rb

@@ -12,14 +12,33 @@ module Mui
     end
 
     def execute(name, context, *)
-      command = @commands[name.to_sym]
+      command = find(name)
       raise UnknownCommandError, name unless command
 
       command.call(context, *)
     end
 
     def exists?(name)
-      @commands.key?(name.to_sym)
+      @commands.key?(name.to_sym) || plugin_command_exists?(name)
+    end
+
+    def find(name)
+      # Built-in commands take precedence
+      command = @commands[name.to_sym]
+      return command if command
+
+      # Fall back to plugin commands
+      plugin_commands[name.to_sym]
+    end
+
+    private
+
+    def plugin_command_exists?(name)
+      plugin_commands.key?(name.to_sym)
+    end
+
+    def plugin_commands
+      Mui.config.commands
     end
   end
 end

data/lib/mui/config.rb

@@ -11,7 +11,9 @@ module Mui
         shiftwidth: 2, # Indent width for > and < commands
         expandtab: true, # Use spaces instead of tabs
         tabstop: 8, # Tab display width
-        reselect_after_indent: false # Keep selection after > / < in visual mode
+        reselect_after_indent: false, # Keep selection after > / < in visual mode
+        leader: "\\", # Leader key for key mappings (default: backslash)
+        timeoutlen: 1000 # Timeout for multi-key sequences in milliseconds
       }
       @plugins = []
       @keymaps = {}

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
@@ -196,8 +238,20 @@ module Mui
     end
 
     def render
+      # Force complete redraw if floating window or completion popup was closed
+      # This is needed because multibyte characters (CJK) can be corrupted
+      # when partially overwritten by popups
+      if @floating_window.needs_clear? || @insert_completion_state.needs_clear?
+        @screen.touchwin
+        @insert_completion_state.clear_needs_clear
+      end
+
       @screen.clear
 
+      # Clear the area where the floating window was previously displayed
+      # Must be done before window rendering to avoid overwriting text
+      @floating_window.clear_last_bounds(@screen) if @floating_window.needs_clear?
+
       @tab_bar_renderer.render(@screen, 0)
 
       window.ensure_cursor_visible
@@ -315,5 +369,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/floating_window.rb

@@ -3,7 +3,7 @@
 module Mui
   # A floating window (popup) for displaying temporary content like hover info
   class FloatingWindow
-    attr_reader :content, :row, :col, :width, :height
+    attr_reader :content, :row, :col, :width, :height, :last_bounds
     attr_accessor :visible
 
     def initialize(color_scheme)
@@ -15,6 +15,8 @@ module Mui
       @height = 0
       @visible = false
       @scroll_offset = 0
+      @last_bounds = nil
+      @needs_clear = false
     end
 
     # Show the floating window with content at the specified position
@@ -27,14 +29,49 @@ module Mui
       @scroll_offset = 0
       calculate_dimensions
       @visible = true
+      @needs_clear = false
     end
 
     # Hide the floating window
     def hide
+      return unless @visible
+
+      # Record bounds for clearing on next render
+      @last_bounds = {
+        row: @row,
+        col: @col,
+        width: @width,
+        height: @height
+      }
+      @needs_clear = true
       @visible = false
       @content = []
     end
 
+    # Check if the previous window area needs to be cleared
+    def needs_clear?
+      @needs_clear && @last_bounds
+    end
+
+    # Clear the area where the floating window was previously displayed
+    def clear_last_bounds(screen)
+      return unless needs_clear?
+
+      bounds = @last_bounds
+      adjusted_row, adjusted_col = adjust_position_for_bounds(screen, bounds)
+
+      bounds[:height].times do |i|
+        row = adjusted_row + i
+        next if row.negative? || row >= screen.height
+
+        spaces = " " * bounds[:width]
+        screen.put(row, adjusted_col, spaces)
+      end
+
+      @needs_clear = false
+      @last_bounds = nil
+    end
+
     # Scroll content up
     def scroll_up
       @scroll_offset = [@scroll_offset - 1, 0].max if @visible
@@ -105,6 +142,21 @@ module Mui
       [row, col]
     end
 
+    def adjust_position_for_bounds(screen, bounds)
+      row = bounds[:row]
+      col = bounds[:col]
+
+      # Adjust horizontal position
+      col = screen.width - bounds[:width] if col + bounds[:width] > screen.width
+      col = [col, 0].max
+
+      # Adjust vertical position
+      row = bounds[:row] - bounds[:height] if row + bounds[:height] > screen.height
+      row = [row, 0].max
+
+      [row, col]
+    end
+
     def draw_border(screen, row, col)
       style = @color_scheme[:floating_window] || @color_scheme[:completion_popup]
 

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,10 @@ module Mui
         instance_variable: :syntax_instance_variable,
         global_variable: :syntax_global_variable,
         method_call: :syntax_method_call,
-        type: :syntax_type
+        function_definition: :syntax_function_definition,
+        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/insert_completion_state.rb

@@ -6,16 +6,29 @@ module Mui
     attr_reader :items, :selected_index, :prefix, :original_items
 
     def initialize
-      reset
+      @needs_clear = false
+      reset(set_needs_clear: false)
     end
 
-    def reset
+    def reset(set_needs_clear: true)
+      # Set needs_clear flag if we had items (popup was visible)
+      @needs_clear = true if set_needs_clear && !@items.empty?
       @items = []
       @original_items = []
       @selected_index = 0
       @prefix = ""
     end
 
+    # Check if the previous popup area needs to be cleared
+    def needs_clear?
+      @needs_clear
+    end
+
+    # Clear the needs_clear flag after redraw
+    def clear_needs_clear
+      @needs_clear = false
+    end
+
     def active?
       !@items.empty?
     end

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