ruvim 0.1.0 → 0.3.0

data/lib/ruvim/global_commands.rb

@@ -1,8 +1,13 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require "open3"
+
 module RuVim
   class GlobalCommands
     include Singleton
 
-    def call(spec_call, ctx, argv: [], kwargs: {}, bang: false, count: 1)
+    def call(spec_call, ctx, argv: [], kwargs: {}, bang: false, count: nil)
       case spec_call
       when Symbol, String
         public_send(spec_call.to_sym, ctx, argv: argv, kwargs: kwargs, bang: bang, count: count)
@@ -12,19 +17,19 @@ module RuVim
     end
 
     def cursor_left(ctx, count:, **)
-      ctx.window.move_left(ctx.buffer, count)
+      move_cursor_horizontally(ctx, direction: :left, count:)
     end
 
     def cursor_right(ctx, count:, **)
-      ctx.window.move_right(ctx.buffer, count)
+      move_cursor_horizontally(ctx, direction: :right, count:)
     end
 
     def cursor_up(ctx, count:, **)
-      ctx.window.move_up(ctx.buffer, count)
+      ctx.window.move_up(ctx.buffer, normalized_count(count))
     end
 
     def cursor_down(ctx, count:, **)
-      ctx.window.move_down(ctx.buffer, count)
+      ctx.window.move_down(ctx.buffer, normalized_count(count))
     end
 
     def cursor_page_up(ctx, kwargs:, count:, **)
@@ -37,6 +42,50 @@ module RuVim
       ctx.window.move_down(ctx.buffer, page_lines * [count.to_i, 1].max)
     end
 
+    def cursor_page_up_default(ctx, count:, bang:, **)
+      call(:cursor_page_up, ctx, count:, bang:, kwargs: { page_lines: current_page_step_lines(ctx) })
+    end
+
+    def cursor_page_down_default(ctx, count:, bang:, **)
+      call(:cursor_page_down, ctx, count:, bang:, kwargs: { page_lines: current_page_step_lines(ctx) })
+    end
+
+    def cursor_page_up_half(ctx, count:, bang:, **)
+      call(:cursor_page_up, ctx, count:, bang:, kwargs: { page_lines: current_half_page_step_lines(ctx) })
+    end
+
+    def cursor_page_down_half(ctx, count:, bang:, **)
+      call(:cursor_page_down, ctx, count:, bang:, kwargs: { page_lines: current_half_page_step_lines(ctx) })
+    end
+
+    def window_scroll_up(ctx, kwargs:, count:, **)
+      scroll_window_vertically(ctx, direction: :up, lines: kwargs[:lines] || kwargs["lines"], view_height: kwargs[:view_height] || kwargs["view_height"], count:)
+    end
+
+    def window_scroll_down(ctx, kwargs:, count:, **)
+      scroll_window_vertically(ctx, direction: :down, lines: kwargs[:lines] || kwargs["lines"], view_height: kwargs[:view_height] || kwargs["view_height"], count:)
+    end
+
+    def window_scroll_up_line(ctx, count:, bang:, **)
+      call(:window_scroll_up, ctx, count:, bang:, kwargs: { lines: 1, view_height: current_view_height(ctx) + 1 })
+    end
+
+    def window_scroll_down_line(ctx, count:, bang:, **)
+      call(:window_scroll_down, ctx, count:, bang:, kwargs: { lines: 1, view_height: current_view_height(ctx) + 1 })
+    end
+
+    def window_cursor_line_top(ctx, count:, **)
+      place_cursor_line_in_window(ctx, where: :top, count:)
+    end
+
+    def window_cursor_line_center(ctx, count:, **)
+      place_cursor_line_in_window(ctx, where: :center, count:)
+    end
+
+    def window_cursor_line_bottom(ctx, count:, **)
+      place_cursor_line_in_window(ctx, where: :bottom, count:)
+    end
+
     def cursor_line_start(ctx, **)
       ctx.window.cursor_x = 0
       ctx.window.clamp_to_buffer(ctx.buffer)
@@ -56,7 +105,7 @@ module RuVim
 
     def cursor_buffer_start(ctx, count:, **)
       record_jump(ctx)
-      target_row = [count.to_i - 1, 0].max
+      target_row = [normalized_count(count).to_i - 1, 0].max
       target_row = [target_row, ctx.buffer.line_count - 1].min
       ctx.window.cursor_y = target_row
       cursor_first_nonblank(ctx)
@@ -64,11 +113,7 @@ module RuVim
 
     def cursor_buffer_end(ctx, count:, **)
       record_jump(ctx)
-      if count && count > 1
-        target_row = [count - 1, ctx.buffer.line_count - 1].min
-      else
-        target_row = ctx.buffer.line_count - 1
-      end
+      target_row = count.nil? ? (ctx.buffer.line_count - 1) : [normalized_count(count) - 1, ctx.buffer.line_count - 1].min
       ctx.window.cursor_y = target_row
       cursor_first_nonblank(ctx)
     end
@@ -121,6 +166,7 @@ module RuVim
 
     def enter_insert_mode(ctx, **)
       materialize_intro_buffer_if_needed(ctx)
+      ensure_modifiable_for_insert!(ctx)
       ctx.buffer.begin_change_group
       ctx.editor.enter_insert_mode
       ctx.editor.echo("-- INSERT --")
@@ -145,10 +191,12 @@ module RuVim
 
     def open_line_below(ctx, **)
       materialize_intro_buffer_if_needed(ctx)
+      ensure_modifiable_for_insert!(ctx)
       y = ctx.window.cursor_y
       x = ctx.buffer.line_length(y)
       ctx.buffer.begin_change_group
       new_y, new_x = ctx.buffer.insert_newline(y, x)
+      new_x = apply_autoindent_to_newline(ctx, row: new_y, previous_row: y, start_col: new_x)
       ctx.window.cursor_y = new_y
       ctx.window.cursor_x = new_x
       ctx.editor.enter_insert_mode
@@ -157,10 +205,13 @@ module RuVim
 
     def open_line_above(ctx, **)
       materialize_intro_buffer_if_needed(ctx)
+      ensure_modifiable_for_insert!(ctx)
       y = ctx.window.cursor_y
       ctx.buffer.begin_change_group
-      ctx.buffer.insert_newline(y, 0)
-      ctx.window.cursor_x = 0
+      _new_y, new_x = ctx.buffer.insert_newline(y, 0)
+      new_x = apply_autoindent_to_newline(ctx, row: y, previous_row: y + 1, start_col: 0)
+      ctx.window.cursor_y = y
+      ctx.window.cursor_x = new_x
       ctx.editor.enter_insert_mode
       ctx.editor.echo("-- INSERT --")
     end
@@ -181,12 +232,14 @@ module RuVim
     end
 
     def window_split(ctx, **)
-      ctx.editor.split_current_window(layout: :horizontal)
+      place = ctx.editor.effective_option("splitbelow", window: ctx.window, buffer: ctx.buffer) ? :after : :before
+      ctx.editor.split_current_window(layout: :horizontal, place:)
       ctx.editor.echo("split")
     end
 
     def window_vsplit(ctx, **)
-      ctx.editor.split_current_window(layout: :vertical)
+      place = ctx.editor.effective_option("splitright", window: ctx.window, buffer: ctx.buffer) ? :after : :before
+      ctx.editor.split_current_window(layout: :vertical, place:)
       ctx.editor.echo("vsplit")
     end
 
@@ -210,30 +263,83 @@ module RuVim
       ctx.editor.focus_window_direction(:down)
     end
 
-    def tab_new(ctx, argv:, **)
-      path = argv[0]
-      if ctx.buffer.modified?
-        ctx.editor.echo_error("Unsaved changes (use :w or :q!)")
-        return
+    def window_focus_or_split_left(ctx, **)
+      ed = ctx.editor
+      if ed.has_split_ancestor_on_axis?(:left)
+        ed.focus_window_direction(:left)
+      else
+        ed.split_current_window(layout: :vertical, place: :before)
+      end
+    end
+
+    def window_focus_or_split_right(ctx, **)
+      ed = ctx.editor
+      if ed.has_split_ancestor_on_axis?(:right)
+        ed.focus_window_direction(:right)
+      else
+        ed.split_current_window(layout: :vertical, place: :after)
       end
-      tab = ctx.editor.tabnew(path: path)
-      if path && !path.empty?
-        b = ctx.editor.current_buffer
-        ctx.editor.echo("tab #{ctx.editor.current_tabpage_number}/#{ctx.editor.tabpage_count}: #{b.path || '[No Name]'}")
+    end
+
+    def window_focus_or_split_up(ctx, **)
+      ed = ctx.editor
+      if ed.has_split_ancestor_on_axis?(:up)
+        ed.focus_window_direction(:up)
       else
-        ctx.editor.echo("tab #{ctx.editor.current_tabpage_number}/#{ctx.editor.tabpage_count}")
+        ed.split_current_window(layout: :horizontal, place: :before)
+      end
+    end
+
+    def window_focus_or_split_down(ctx, **)
+      ed = ctx.editor
+      if ed.has_split_ancestor_on_axis?(:down)
+        ed.focus_window_direction(:down)
+      else
+        ed.split_current_window(layout: :horizontal, place: :after)
+      end
+    end
+
+    def tab_new(ctx, argv:, **)
+      path = argv[0]
+      if ctx.buffer.modified? && !ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+        unless maybe_autowrite_before_switch(ctx)
+          ctx.editor.echo_error("Unsaved changes (use :w or :q!)")
+          return
+        end
       end
-      tab
+      ctx.editor.tabnew(path: path)
     end
 
     def tab_next(ctx, count:, **)
+      count = normalized_count(count)
       ctx.editor.tabnext(count)
-      ctx.editor.echo("tab #{ctx.editor.current_tabpage_number}/#{ctx.editor.tabpage_count}")
     end
 
     def tab_prev(ctx, count:, **)
+      count = normalized_count(count)
       ctx.editor.tabprev(count)
-      ctx.editor.echo("tab #{ctx.editor.current_tabpage_number}/#{ctx.editor.tabpage_count}")
+    end
+
+    def tab_list(ctx, **)
+      editor = ctx.editor
+      items = []
+      # For current tab, use live window_order; for others, use saved snapshot
+      editor.tabpages.each_with_index do |tab, i|
+        is_current = (i == editor.current_tabpage_index)
+        current_marker = is_current ? ">" : " "
+        items << "#{current_marker}Tab page #{i + 1}"
+        win_ids = is_current ? editor.window_order : editor.tabpage_windows(tab)
+        win_ids.each do |wid|
+          win = editor.windows[wid]
+          next unless win
+          buf = editor.buffers[win.buffer_id]
+          next unless buf
+          active = (is_current && wid == editor.current_window_id) ? ">" : " "
+          name = buf.display_name
+          items << "  #{active} #{name}"
+        end
+      end
+      editor.echo_multiline(items)
     end
 
     def enter_command_line_mode(ctx, **)
@@ -253,6 +359,7 @@ module RuVim
 
     def delete_char(ctx, count:, **)
       materialize_intro_buffer_if_needed(ctx)
+      count = normalized_count(count)
       ctx.buffer.begin_change_group
       deleted = +""
       count.times do
@@ -266,8 +373,80 @@ module RuVim
       ctx.window.clamp_to_buffer(ctx.buffer)
     end
 
+    def substitute_char(ctx, count:, bang:, **)
+      call(:change_motion, ctx, count:, bang:, kwargs: { motion: "l" })
+    end
+
+    def swapcase_char(ctx, count:, **)
+      materialize_intro_buffer_if_needed(ctx)
+      count = normalized_count(count)
+
+      y = ctx.window.cursor_y
+      x = ctx.window.cursor_x
+      processed = false
+
+      ctx.buffer.begin_change_group
+      count.times do
+        line = ctx.buffer.line_at(y)
+        break if x >= line.length
+
+        ch = line[x]
+        swapped = ch.to_s.swapcase
+        if !swapped.empty? && swapped != ch
+          ctx.buffer.delete_span(y, x, y, x + 1)
+          ctx.buffer.insert_char(y, x, swapped[0])
+        end
+        processed = true
+        x += 1
+      end
+      ctx.buffer.end_change_group
+
+      ctx.window.cursor_y = y
+      ctx.window.cursor_x = processed ? x : ctx.window.cursor_x
+      ctx.window.clamp_to_buffer(ctx.buffer)
+    end
+
+    def join_lines(ctx, count:, **)
+      materialize_intro_buffer_if_needed(ctx)
+      joins = [normalized_count(count) - 1, 1].max
+      y = ctx.window.cursor_y
+      x = ctx.window.cursor_x
+      changed = false
+
+      ctx.buffer.begin_change_group
+      joins.times do
+        break if y >= ctx.buffer.line_count - 1
+
+        left = ctx.buffer.line_at(y)
+        right = ctx.buffer.line_at(y + 1)
+        join_col = left.length
+
+        # Join raw lines first.
+        break unless ctx.buffer.delete_char(y, join_col)
+
+        right_trimmed = right.sub(/\A\s+/, "")
+        trimmed_count = right.length - right_trimmed.length
+        if trimmed_count.positive?
+          ctx.buffer.delete_span(y, join_col, y, join_col + trimmed_count)
+        end
+
+        need_space = !left.empty? && !left.match?(/\s\z/) && !right_trimmed.empty? && !right_trimmed.match?(/\A\s/)
+        ctx.buffer.insert_char(y, join_col, " ") if need_space
+
+        x = join_col
+        changed = true
+      end
+      ctx.buffer.end_change_group
+
+      ctx.window.cursor_y = y
+      ctx.window.cursor_x = x
+      ctx.window.clamp_to_buffer(ctx.buffer)
+      ctx.editor.echo("joined") if changed
+    end
+
     def delete_line(ctx, count:, **)
       materialize_intro_buffer_if_needed(ctx)
+      count = normalized_count(count)
       ctx.buffer.begin_change_group
       deleted_lines = []
       count.times { deleted_lines << ctx.buffer.delete_line(ctx.window.cursor_y) }
@@ -279,14 +458,15 @@ module RuVim
     def delete_motion(ctx, count:, kwargs:, **)
       materialize_intro_buffer_if_needed(ctx)
       motion = (kwargs[:motion] || kwargs["motion"]).to_s
+      ncount = normalized_count(count)
       handled =
         case motion
-        when "h" then delete_chars_left(ctx, count)
-        when "l" then delete_chars_right(ctx, count)
-        when "j" then delete_lines_down(ctx, count)
-        when "k" then delete_lines_up(ctx, count)
+        when "h" then delete_chars_left(ctx, ncount)
+        when "l" then delete_chars_right(ctx, ncount)
+        when "j" then delete_lines_down(ctx, ncount)
+        when "k" then delete_lines_up(ctx, ncount)
         when "$" then delete_to_end_of_line(ctx)
-        when "w" then delete_word_forward(ctx, count)
+        when "w" then delete_word_forward(ctx, ncount)
         when "iw" then delete_text_object_word(ctx, around: false)
         when "aw" then delete_text_object_word(ctx, around: true)
         else
@@ -391,6 +571,7 @@ module RuVim
 
     def replace_char(ctx, argv:, count:, **)
       materialize_intro_buffer_if_needed(ctx)
+      count = normalized_count(count)
       ch = argv[0].to_s
       raise RuVim::CommandError, "replace requires a character" if ch.empty?
 
@@ -411,6 +592,7 @@ module RuVim
     end
 
     def yank_line(ctx, count:, **)
+      count = normalized_count(count)
       start = ctx.window.cursor_y
       text = ctx.buffer.line_block_text(start, count)
       store_yank_register(ctx, text:, type: :linewise)
@@ -423,7 +605,7 @@ module RuVim
       when "w"
         y = ctx.window.cursor_y
         x = ctx.window.cursor_x
-        target = advance_word_forward(ctx.buffer, y, x, count)
+        target = advance_word_forward(ctx.buffer, y, x, count, editor: ctx.editor, window: ctx.window)
         target ||= { row: y, col: x }
         text = ctx.buffer.span_text(y, x, target[:row], target[:col])
         store_yank_register(ctx, text:, type: :charwise)
@@ -515,6 +697,45 @@ module RuVim
       ctx.editor.enter_normal_mode
     end
 
+    def indent_lines(ctx, count:, **)
+      count = normalized_count(count)
+      start_row = ctx.window.cursor_y
+      end_row = [start_row + count - 1, ctx.buffer.line_count - 1].min
+      reindent_range(ctx, start_row, end_row)
+    end
+
+    def indent_motion(ctx, count:, kwargs:, **)
+      motion = (kwargs[:motion] || kwargs["motion"]).to_s
+      ncount = normalized_count(count)
+      start_row = ctx.window.cursor_y
+      case motion
+      when "j"
+        end_row = [start_row + ncount, ctx.buffer.line_count - 1].min
+      when "k"
+        end_row = start_row
+        start_row = [start_row - ncount, 0].max
+      when "G"
+        end_row = ctx.buffer.line_count - 1
+      when "gg"
+        end_row = start_row
+        start_row = 0
+      else
+        ctx.editor.echo("Unsupported motion for =: #{motion}")
+        return
+      end
+      reindent_range(ctx, start_row, end_row)
+    end
+
+    def visual_indent(ctx, **)
+      sel = ctx.editor.visual_selection
+      return unless sel
+
+      start_row = sel[:start_row]
+      end_row = sel[:end_row]
+      reindent_range(ctx, start_row, end_row)
+      ctx.editor.enter_normal_mode
+    end
+
     def visual_select_text_object(ctx, kwargs:, **)
       motion = (kwargs[:motion] || kwargs["motion"]).to_s
       span = text_object_span(ctx.buffer, ctx.window, motion)
@@ -540,6 +761,9 @@ module RuVim
       size = File.exist?(target) ? File.size(target) : 0
       suffix = bang ? " (force accepted)" : ""
       ctx.editor.echo("\"#{target}\" #{ctx.buffer.line_count}L, #{size}B written#{suffix}")
+      if ctx.editor.get_option("onsavehook")
+        ctx.buffer.lang_module.on_save(ctx, target)
+      end
     end
 
     def app_quit(ctx, bang:, **)
@@ -563,6 +787,25 @@ module RuVim
       ctx.editor.request_quit!
     end
 
+    def app_quit_all(ctx, bang:, **)
+      unless bang
+        modified = ctx.editor.buffers.values.select { |b| b.file_buffer? && b.modified? }
+        unless modified.empty?
+          ctx.editor.echo_error("#{modified.size} buffer(s) have unsaved changes (add ! to override)")
+          return
+        end
+      end
+      ctx.editor.request_quit!
+    end
+
+    def file_write_quit_all(ctx, bang:, **)
+      ctx.editor.buffers.each_value do |buf|
+        next unless buf.file_buffer? && buf.modified? && buf.path
+        buf.write_to(buf.path)
+      end
+      app_quit_all(ctx, bang: true)
+    end
+
     def file_write_quit(ctx, argv:, bang:, **)
       file_write(ctx, argv:, bang:)
       return unless ctx.editor.running?
@@ -587,13 +830,42 @@ module RuVim
       end
 
       if ctx.buffer.modified? && !bang
-        ctx.editor.echo_error("Unsaved changes (use :e! to discard and open)")
+        if ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+          # hidden permits abandoning a modified buffer without forcing write.
+        elsif maybe_autowrite_before_switch(ctx)
+          # autowrite handled
+        else
+          ctx.editor.echo_error("Unsaved changes (use :e! to discard and open)")
+          return
+        end
+      end
+
+      ctx.editor.open_path(path)
+    end
+
+    def file_goto_under_cursor(ctx, **)
+      token = file_token_under_cursor(ctx.buffer, ctx.window)
+      if token.nil? || token.empty?
+        ctx.editor.echo_error("No file under cursor")
         return
       end
 
-      new_buffer = ctx.editor.add_buffer_from_file(path)
-      ctx.editor.switch_to_buffer(new_buffer.id)
-      ctx.editor.echo(File.exist?(path) ? "\"#{path}\" #{new_buffer.line_count}L" : "\"#{path}\" [New File]")
+      target = parse_gf_target(token)
+      path = resolve_gf_path(ctx, target[:path])
+      unless path
+        ctx.editor.echo_error("File not found: #{target[:path]}")
+        return
+      end
+
+      if ctx.buffer.modified? && !ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+        unless maybe_autowrite_before_switch(ctx)
+          ctx.editor.echo_error("Unsaved changes (set hidden or :w)")
+          return
+        end
+      end
+
+      ctx.editor.open_path(path)
+      move_cursor_to_gf_line(ctx, target[:line]) if target[:line]
     end
 
     def buffer_list(ctx, **)
@@ -601,23 +873,28 @@ module RuVim
       alt_id = ctx.editor.alternate_buffer_id
       items = ctx.editor.buffer_ids.map do |id|
         b = ctx.editor.buffers.fetch(id)
-        flags = ""
-        flags << "%" if id == current_id
-        flags << "#" if id == alt_id
-        flags << "+" if b.modified?
-        path = b.path || "[No Name]"
-        "#{id}#{flags} #{path}"
+        indicator = id == current_id ? "%a" : "  "
+        indicator = "# " if id == alt_id && id != current_id
+        mod = b.modified? ? "+" : " "
+        name = b.path ? "\"#{b.path}\"" : "[No Name]"
+        line_info = "line #{b.respond_to?(:cursor_line) ? b.cursor_line : 0}"
+        # Find the window showing this buffer to get cursor line
+        win = ctx.editor.windows.values.find { |w| w.buffer_id == id }
+        line_info = "line #{win ? win.cursor_y + 1 : 0}"
+        "%3d %s %s %-30s %s" % [id, indicator, mod, name, line_info]
       end
-      ctx.editor.echo(items.join(" | "))
+      ctx.editor.echo_multiline(items)
     end
 
     def buffer_next(ctx, count:, bang:, **)
+      count = normalized_count(count)
       target = ctx.editor.current_buffer.id
       count.times { target = ctx.editor.next_buffer_id_from(target, 1) }
       switch_buffer_id(ctx, target, bang:)
     end
 
     def buffer_prev(ctx, count:, bang:, **)
+      count = normalized_count(count)
       target = ctx.editor.current_buffer.id
       count.times { target = ctx.editor.next_buffer_id_from(target, -1) }
       switch_buffer_id(ctx, target, bang:)
@@ -639,6 +916,28 @@ module RuVim
       switch_buffer_id(ctx, target_id, bang:)
     end
 
+    def buffer_delete(ctx, argv:, bang:, **)
+      arg = argv[0]
+      target_id =
+        if arg.nil? || arg.empty?
+          ctx.buffer.id
+        elsif arg == "#"
+          ctx.editor.alternate_buffer_id || raise(RuVim::CommandError, "No alternate buffer")
+        elsif arg.match?(/\A\d+\z/)
+          arg.to_i
+        else
+          find_buffer_by_name(ctx.editor, arg)&.id || raise(RuVim::CommandError, "No such buffer: #{arg}")
+        end
+
+      target = ctx.editor.buffers[target_id] || raise(RuVim::CommandError, "No such buffer: #{target_id}")
+      if target.modified? && !bang
+        raise RuVim::CommandError, "No write since last change (use :bdelete! to discard)"
+      end
+
+      ctx.editor.delete_buffer(target_id)
+      ctx.editor.echo("buffer #{target_id} deleted")
+    end
+
     def ex_help(ctx, argv: [], **)
       topic = argv.first.to_s
       registry = RuVim::ExCommandRegistry.instance
@@ -675,7 +974,7 @@ module RuVim
       when "config"
         "Config: XDG Ruby DSL at ~/.config/ruvim/init.rb and ftplugin/<filetype>.rb"
       when "bindings", "keys", "keymap"
-        "Bindings: see docs/binding.md. Ex complement: Tab, insert completion: Ctrl-n/Ctrl-p"
+        "Bindings: use :bindings (current effective key bindings by layer). Docs: docs/binding.md"
       when "number", "relativenumber", "ignorecase", "smartcase", "hlsearch", "tabstop", "filetype"
         option_help_line(key)
       else
@@ -691,8 +990,17 @@ module RuVim
     def ex_define_command(ctx, argv:, bang:, **)
       registry = RuVim::ExCommandRegistry.instance
       if argv.empty?
-        items = registry.all.select { |spec| spec.source == :user }.map(&:name)
-        ctx.editor.echo(items.empty? ? "No user commands" : "User commands: #{items.join(', ')}")
+        user_cmds = registry.all.select { |spec| spec.source == :user }
+        if user_cmds.empty?
+          ctx.editor.echo("No user commands")
+        else
+          header = "    Name        Definition"
+          items = [header] + user_cmds.map { |spec|
+            body = spec.respond_to?(:body) ? spec.body.to_s : spec.name.to_s
+            "    %-12s%s" % [spec.name, body]
+          }
+          ctx.editor.echo_multiline(items)
+        end
         return
       end
 
@@ -724,24 +1032,128 @@ module RuVim
       raise RuVim::CommandError, "Usage: :ruby <code>" if code.strip.empty?
 
       b = binding
+      # Use local_variable_set for eval locals to avoid "assigned but unused variable"
+      # warnings while still exposing editor/buffer/window in :ruby.
       b.local_variable_set(:editor, ctx.editor)
       b.local_variable_set(:buffer, ctx.buffer)
       b.local_variable_set(:window, ctx.window)
-      result = eval(code, b) # rubocop:disable Security/Eval
-      ctx.editor.echo(result.nil? ? "ruby: nil" : "ruby: #{result.inspect}")
+      saved_stdout = STDOUT.dup
+      saved_stderr = STDERR.dup
+      original_g_stdout = $stdout
+      original_g_stderr = $stderr
+      result = nil
+      stdout_text = ""
+      stderr_text = ""
+      Tempfile.create("ruvim-ruby-stdout") do |outf|
+        Tempfile.create("ruvim-ruby-stderr") do |errf|
+          STDOUT.reopen(outf)
+          STDERR.reopen(errf)
+          $stdout = STDOUT
+          $stderr = STDERR
+          result = eval(code, b) # rubocop:disable Security/Eval
+          STDOUT.flush
+          STDERR.flush
+          outf.flush
+          errf.flush
+          outf.rewind
+          errf.rewind
+          stdout_text = outf.read.to_s
+          stderr_text = errf.read.to_s
+        end
+      end
+      if !stdout_text.empty? || !stderr_text.empty?
+        lines = ["Ruby output", ""]
+        unless stdout_text.empty?
+          lines << "[stdout]"
+          lines.concat(stdout_text.lines(chomp: true))
+          lines << ""
+        end
+        unless stderr_text.empty?
+          lines << "[stderr]"
+          lines.concat(stderr_text.lines(chomp: true))
+          lines << ""
+        end
+        lines << "[result]"
+        lines << (result.nil? ? "nil" : result.inspect)
+        ctx.editor.show_help_buffer!(title: "[Ruby Output]", lines:, filetype: "ruby")
+      else
+        ctx.editor.echo(result.nil? ? "ruby: nil" : "ruby: #{result.inspect}")
+      end
     rescue StandardError => e
       raise RuVim::CommandError, "Ruby error: #{e.class}: #{e.message}"
+    ensure
+      if defined?(saved_stdout) && saved_stdout
+        STDOUT.reopen(saved_stdout)
+        saved_stdout.close unless saved_stdout.closed?
+      end
+      if defined?(saved_stderr) && saved_stderr
+        STDERR.reopen(saved_stderr)
+        saved_stderr.close unless saved_stderr.closed?
+      end
+      $stdout = (defined?(original_g_stdout) && original_g_stdout) ? original_g_stdout : STDOUT
+      $stderr = (defined?(original_g_stderr) && original_g_stderr) ? original_g_stderr : STDERR
+    end
+
+    def ex_shell(ctx, command:, **)
+      raise RuVim::CommandError, "Restricted mode: :! is disabled" if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
+      cmd = command.to_s
+      raise RuVim::CommandError, "Usage: :!<command>" if cmd.strip.empty?
+
+      shell = ENV["SHELL"].to_s
+      shell = "/bin/sh" if shell.empty?
+      stdout_text, stderr_text, status = Open3.capture3(shell, "-c", cmd)
+
+      if !stdout_text.to_s.empty? || !stderr_text.to_s.empty?
+        lines = ["Shell output", "", "[command]", cmd, ""]
+        unless stdout_text.to_s.empty?
+          lines << "[stdout]"
+          lines.concat(stdout_text.to_s.lines(chomp: true))
+          lines << ""
+        end
+        unless stderr_text.to_s.empty?
+          lines << "[stderr]"
+          lines.concat(stderr_text.to_s.lines(chomp: true))
+          lines << ""
+        end
+        lines << "[status]"
+        lines << "exit #{status.exitstatus}"
+        ctx.editor.show_help_buffer!(title: "[Shell Output]", lines:, filetype: "sh")
+      else
+        ctx.editor.echo("shell exit #{status.exitstatus}")
+      end
+    rescue Errno::ENOENT => e
+      raise RuVim::CommandError, "Shell error: #{e.message}"
     end
 
     def ex_commands(ctx, **)
-      items = RuVim::ExCommandRegistry.instance.all.map do |spec|
+      rows = RuVim::ExCommandRegistry.instance.all.map do |spec|
         alias_text = spec.aliases.empty? ? "" : " (#{spec.aliases.join(', ')})"
         source = spec.source == :user ? " [user]" : ""
-        "#{spec.name}#{alias_text}#{source}"
+        name = "#{spec.name}#{alias_text}#{source}"
+        desc = spec.desc.to_s
+        keys = ex_command_binding_labels(ctx.editor, spec)
+        [name, desc, keys]
+      end
+      name_width = rows.map { |name, _desc, _keys| name.length }.max || 0
+      items = rows.map do |name, desc, keys|
+        line = "#{name.ljust(name_width)}  #{desc}"
+        line += "  keys: #{keys.join(', ')}" unless keys.empty?
+        line
       end
       ctx.editor.show_help_buffer!(title: "[Commands]", lines: ["Ex commands", "", *items])
     end
 
+    def ex_bindings(ctx, argv: [], **)
+      keymaps = ctx.editor.keymap_manager
+      raise RuVim::CommandError, "Keymap manager is unavailable" unless keymaps
+
+      mode_filter, sort = parse_bindings_args(argv)
+      entries = keymaps.binding_entries_for_context(ctx.editor, mode: mode_filter)
+      lines = bindings_buffer_lines(ctx.editor, entries, mode_filter:, sort:)
+      ctx.editor.show_help_buffer!(title: "[Bindings]", lines:)
+    end
+
     def ex_set(ctx, argv:, **)
       ex_set_common(ctx, argv, scope: :auto)
     end
@@ -764,6 +1176,7 @@ module RuVim
       end
 
       ctx.editor.set_quickfix_list(items)
+      ctx.editor.select_quickfix(0)
       ctx.editor.jump_to_location(ctx.editor.current_quickfix_item)
       ctx.editor.echo("quickfix: #{items.length} item(s)")
     end
@@ -778,12 +1191,13 @@ module RuVim
       end
 
       ctx.editor.set_location_list(items, window_id: ctx.window.id)
+      ctx.editor.select_location_list(0, window_id: ctx.window.id)
       ctx.editor.jump_to_location(ctx.editor.current_location_list_item(ctx.window.id))
       ctx.editor.echo("location list: #{items.length} item(s)")
     end
 
     def ex_copen(ctx, **)
-      open_list_window(ctx, kind: :quickfix, title: "[Quickfix]", lines: quickfix_buffer_lines(ctx.editor))
+      open_list_window(ctx, kind: :quickfix, title: "[Quickfix]", lines: quickfix_buffer_lines(ctx.editor), source_window_id: ctx.window.id)
     end
 
     def ex_cclose(ctx, **)
@@ -797,6 +1211,7 @@ module RuVim
         return
       end
       ctx.editor.jump_to_location(item)
+      refresh_list_window(ctx.editor, :quickfix)
       ctx.editor.echo(quickfix_item_echo(ctx.editor))
     end
 
@@ -807,11 +1222,13 @@ module RuVim
         return
       end
       ctx.editor.jump_to_location(item)
+      refresh_list_window(ctx.editor, :quickfix)
       ctx.editor.echo(quickfix_item_echo(ctx.editor))
     end
 
     def ex_lopen(ctx, **)
-      open_list_window(ctx, kind: :location_list, title: "[Location List]", lines: location_list_buffer_lines(ctx.editor, ctx.window.id))
+      open_list_window(ctx, kind: :location_list, title: "[Location List]", lines: location_list_buffer_lines(ctx.editor, ctx.window.id),
+                       source_window_id: ctx.window.id)
     end
 
     def ex_lclose(ctx, **)
@@ -825,6 +1242,7 @@ module RuVim
         return
       end
       ctx.editor.jump_to_location(item)
+      refresh_list_window(ctx.editor, :location_list)
       ctx.editor.echo(location_item_echo(ctx.editor, ctx.window.id))
     end
 
@@ -835,37 +1253,89 @@ module RuVim
         return
       end
       ctx.editor.jump_to_location(item)
+      refresh_list_window(ctx.editor, :location_list)
       ctx.editor.echo(location_item_echo(ctx.editor, ctx.window.id))
     end
 
-    def ex_substitute(ctx, pattern:, replacement:, global: false, **)
+    def ex_substitute(ctx, pattern:, replacement:, flags_str: nil, range_start: nil, range_end: nil, global: false, **)
       materialize_intro_buffer_if_needed(ctx)
-      regex = compile_search_regex(pattern, editor: ctx.editor, window: ctx.window, buffer: ctx.buffer)
-      changed = 0
-      new_lines = ctx.buffer.lines.map do |line|
-        if global
-          line.scan(regex) { changed += 1 }
-          line.gsub(regex, replacement)
-        else
-          if line.match?(regex)
-            changed += 1
-            line.sub(regex, replacement)
-          else
-            line
-          end
-        end
+      flags = parse_substitute_flags(flags_str, default_global: global)
+      raise RuVim::CommandError, "Confirm flag (:s///c) is not yet supported" if flags[:confirm]
+
+      regex = build_substitute_regex(pattern, flags, ctx)
+
+      r_start = range_start || 0
+      r_end = range_end || (ctx.buffer.line_count - 1)
+
+      if flags[:count_only]
+        total = count_matches_in_range(ctx.buffer, regex, r_start, r_end, flags[:global])
+        ctx.editor.echo("#{total} match(es)")
+        return
       end
 
+      changed = substitute_range(ctx, regex, replacement, r_start, r_end, flags)
+
       if changed.positive?
-        ctx.buffer.begin_change_group
-        ctx.buffer.replace_all_lines!(new_lines)
-        ctx.buffer.end_change_group
         ctx.editor.echo("#{changed} substitution(s)")
+      elsif flags[:no_error]
+        ctx.editor.echo("Pattern not found: #{pattern}")
       else
         ctx.editor.echo("Pattern not found: #{pattern}")
       end
     end
 
+    def ex_grep(ctx, argv:, kwargs: {}, **)
+      run_external_grep(ctx, argv:, target: :quickfix)
+    end
+
+    def ex_lgrep(ctx, argv:, kwargs: {}, **)
+      run_external_grep(ctx, argv:, target: :location_list)
+    end
+
+    def ex_delete_lines(ctx, kwargs: {}, **)
+      materialize_intro_buffer_if_needed(ctx)
+      r_start = kwargs[:range_start]
+      r_end = kwargs[:range_end]
+      unless r_start && r_end
+        # Default to current line
+        r_start = r_end = ctx.window.cursor_y
+      end
+
+      count = r_end - r_start + 1
+      deleted_text = ctx.buffer.line_block_text(r_start, count)
+      ctx.buffer.begin_change_group
+      count.times { ctx.buffer.delete_line(r_start) }
+      ctx.buffer.end_change_group
+      store_delete_register(ctx, text: deleted_text, type: :linewise)
+      ctx.window.cursor_y = [r_start, ctx.buffer.line_count - 1].min
+      ctx.window.cursor_x = 0
+      ctx.window.clamp_to_buffer(ctx.buffer)
+      ctx.editor.echo("#{count} line(s) deleted")
+    end
+
+    def ex_yank_lines(ctx, kwargs: {}, **)
+      materialize_intro_buffer_if_needed(ctx)
+      r_start = kwargs[:range_start]
+      r_end = kwargs[:range_end]
+      unless r_start && r_end
+        r_start = r_end = ctx.window.cursor_y
+      end
+
+      count = r_end - r_start + 1
+      text = ctx.buffer.line_block_text(r_start, count)
+      store_yank_register(ctx, text:, type: :linewise)
+      ctx.editor.echo("#{count} line(s) yanked")
+    end
+
+    def ex_rich(ctx, argv: [], **)
+      format = argv.first
+      RuVim::RichView.toggle!(ctx.editor, format: format)
+    end
+
+    def rich_toggle(ctx, **)
+      RuVim::RichView.toggle!(ctx.editor)
+    end
+
     def submit_search(ctx, pattern:, direction:)
       text = pattern.to_s
       if text.empty?
@@ -881,6 +1351,35 @@ module RuVim
 
     private
 
+    def reindent_range(ctx, start_row, end_row)
+      buf = ctx.buffer
+      lang_mod = buf.lang_module
+
+      sw = ctx.editor.effective_option("shiftwidth", buffer: buf).to_i
+      sw = 2 if sw <= 0
+
+      buf.begin_change_group
+      (start_row..end_row).each do |row|
+        target_indent = lang_mod.calculate_indent(buf.lines, row, sw)
+        next unless target_indent
+
+        line = buf.line_at(row)
+        current_indent = line[/\A */].to_s.length
+        next if current_indent == target_indent
+
+        buf.delete_span(row, 0, row, current_indent) if current_indent > 0
+        buf.insert_text(row, 0, " " * target_indent) if target_indent > 0
+      end
+      buf.end_change_group
+
+      ctx.window.cursor_y = start_row
+      line = buf.line_at(start_row)
+      ctx.window.cursor_x = (line[/\A */]&.length || 0)
+      ctx.window.clamp_to_buffer(buf)
+      count = end_row - start_row + 1
+      ctx.editor.echo("#{count} line#{"s" if count > 1} indented")
+    end
+
     def parse_vimgrep_pattern(argv)
       raw = Array(argv).join(" ").strip
       raise RuVim::CommandError, "Usage: :vimgrep /pattern/" if raw.empty?
@@ -892,6 +1391,70 @@ module RuVim
       end
     end
 
+    def run_external_grep(ctx, argv:, target:)
+      args = Array(argv).join(" ").strip
+      raise RuVim::CommandError, "Usage: :grep pattern [files...]" if args.empty?
+
+      grepprg = ctx.editor.effective_option("grepprg", window: ctx.window, buffer: ctx.buffer) || "grep -n"
+      cmd = "#{grepprg} #{args}"
+
+      stdout, stderr, status = Open3.capture3(cmd)
+      if stdout.strip.empty? && !status.success?
+        msg = stderr.strip.empty? ? "No matches found" : stderr.strip
+        ctx.editor.echo_error(msg)
+        return
+      end
+
+      items = parse_grep_output(ctx, stdout)
+      if items.empty?
+        ctx.editor.echo_error("No matches found")
+        return
+      end
+
+      case target
+      when :quickfix
+        ctx.editor.set_quickfix_list(items)
+        ctx.editor.select_quickfix(0)
+        ctx.editor.jump_to_location(ctx.editor.current_quickfix_item)
+        ctx.editor.echo("quickfix: #{items.length} item(s)")
+      when :location_list
+        ctx.editor.set_location_list(items, window_id: ctx.window.id)
+        ctx.editor.select_location_list(0, window_id: ctx.window.id)
+        ctx.editor.jump_to_location(ctx.editor.current_location_list_item(ctx.window.id))
+        ctx.editor.echo("location list: #{items.length} item(s)")
+      end
+    end
+
+    def parse_grep_output(ctx, output)
+      items = []
+      output.each_line do |line|
+        line = line.chomp
+        # Parse filename:lineno:text format
+        if (m = line.match(/\A(.+?):(\d+):(.*)?\z/))
+          filepath = m[1]
+          lineno = m[2].to_i - 1 # 0-based
+          text = m[3].to_s
+          buf = ensure_buffer_for_grep_file(ctx, filepath)
+          items << { buffer_id: buf.id, row: lineno, col: 0, text: text }
+        end
+      end
+      items
+    end
+
+    def ensure_buffer_for_grep_file(ctx, filepath)
+      abspath = File.expand_path(filepath)
+      # Check if buffer already exists for this file
+      existing = ctx.editor.buffers.values.find { |b| b.path && File.expand_path(b.path) == abspath }
+      return existing if existing
+
+      # Create buffer for the file
+      if File.exist?(abspath)
+        ctx.editor.add_buffer_from_file(abspath)
+      else
+        ctx.editor.add_empty_buffer(path: abspath)
+      end
+    end
+
     def grep_items_for_buffers(buffers, regex)
       Array(buffers).flat_map do |buffer|
         buffer.lines.each_with_index.flat_map do |line, row|
@@ -933,10 +1496,11 @@ module RuVim
       ]
     end
 
-    def open_list_window(ctx, kind:, title:, lines:)
+    def open_list_window(ctx, kind:, title:, lines:, source_window_id:)
       editor = ctx.editor
       editor.split_current_window(layout: :horizontal)
       buffer = editor.add_virtual_buffer(kind:, name: title, lines:, filetype: "qf", readonly: true, modifiable: false)
+      buffer.options["ruvim_list_source_window_id"] = source_window_id
       editor.switch_to_buffer(buffer.id)
       editor.echo(title)
       buffer
@@ -956,6 +1520,22 @@ module RuVim
       editor.echo("#{kind} closed")
     end
 
+    def refresh_list_window(editor, kind)
+      wids = editor.find_window_ids_by_buffer_kind(kind)
+      return if wids.empty?
+
+      lines = case kind
+              when :quickfix then quickfix_buffer_lines(editor)
+              when :location_list then location_list_buffer_lines(editor, editor.current_window_id)
+              end
+      wids.each do |wid|
+        buf = editor.buffers[editor.windows[wid].buffer_id]
+        next unless buf
+        # Bypass modifiable check — this is an internal refresh of a readonly list buffer
+        buf.instance_variable_set(:@lines, Array(lines).map(&:dup))
+      end
+    end
+
     def quickfix_item_echo(editor)
       item = editor.current_quickfix_item
       list_item_echo(editor, item, editor.quickfix_index, editor.quickfix_items.length, label: "qf")
@@ -979,9 +1559,11 @@ module RuVim
         raise RuVim::CommandError, "No such buffer: #{buffer_id}"
       end
 
-      if ctx.buffer.modified? && ctx.buffer.id != buffer_id && !bang
-        ctx.editor.echo_error("Unsaved changes (use :w or :buffer! / :bnext! / :bprev!)")
-        return
+      if ctx.buffer.modified? && ctx.buffer.id != buffer_id && !bang && !ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+        unless maybe_autowrite_before_switch(ctx)
+          ctx.editor.echo_error("Unsaved changes (use :w or :buffer! / :bnext! / :bprev!)")
+          return
+        end
       end
 
       record_jump(ctx)
@@ -1017,28 +1599,55 @@ module RuVim
       end.join("\n")
     end
 
+    def apply_autoindent_to_newline(ctx, row:, previous_row:, start_col: 0)
+      return start_col unless ctx.editor.effective_option("autoindent", window: ctx.window, buffer: ctx.buffer)
+
+      prev = ctx.buffer.line_at(previous_row)
+      indent = prev[/\A[ \t]*/].to_s
+
+      if ctx.editor.effective_option("smartindent", window: ctx.window, buffer: ctx.buffer)
+        trimmed = prev.rstrip
+        if trimmed.end_with?("{", "[", "(")
+          sw = ctx.editor.effective_option("shiftwidth", window: ctx.window, buffer: ctx.buffer).to_i
+          sw = 2 if sw <= 0
+          indent += " " * sw
+        end
+      end
+
+      return start_col if indent.empty?
+
+      _y, x = ctx.buffer.insert_text(row, start_col, indent)
+      x
+    end
+
     def search_current_word(ctx, exact:, direction:)
-      word = current_word_under_cursor(ctx.buffer, ctx.window)
+      keyword_rx = keyword_char_regex(ctx.editor, ctx.buffer, ctx.window)
+      word = current_word_under_cursor(ctx.buffer, ctx.window, keyword_rx:)
       if word.nil? || word.empty?
         ctx.editor.echo("No word under cursor")
         return
       end
 
-      pattern = exact ? "\\b#{Regexp.escape(word)}\\b" : Regexp.escape(word)
+      pattern =
+        if exact
+          "(?<!#{keyword_rx.source})#{Regexp.escape(word)}(?!#{keyword_rx.source})"
+        else
+          Regexp.escape(word)
+        end
       ctx.editor.set_last_search(pattern:, direction:)
       move_to_search(ctx, pattern:, direction:, count: 1)
     end
 
-    def current_word_under_cursor(buffer, window)
+    def current_word_under_cursor(buffer, window, keyword_rx: /[[:alnum:]_]/)
       line = buffer.line_at(window.cursor_y)
       return nil if line.empty?
 
       x = [window.cursor_x, line.length - 1].min
       return nil if x.negative?
 
-      if line[x] !~ /[[:alnum:]_]/
+      if !keyword_char?(line[x], keyword_rx)
         left = x - 1
-        if left >= 0 && line[left] =~ /[[:alnum:]_]/
+        if left >= 0 && keyword_char?(line[left], keyword_rx)
           x = left
         else
           return nil
@@ -1046,9 +1655,9 @@ module RuVim
       end
 
       s = x
-      s -= 1 while s.positive? && line[s - 1] =~ /[[:alnum:]_]/
+      s -= 1 while s.positive? && keyword_char?(line[s - 1], keyword_rx)
       e = x + 1
-      e += 1 while e < line.length && line[e] =~ /[[:alnum:]_]/
+      e += 1 while e < line.length && keyword_char?(line[e], keyword_rx)
       line[s...e]
     end
 
@@ -1132,7 +1741,7 @@ module RuVim
     def delete_word_forward(ctx, count)
       y = ctx.window.cursor_y
       x = ctx.window.cursor_x
-      target = advance_word_forward(ctx.buffer, y, x, count)
+      target = advance_word_forward(ctx.buffer, y, x, count, editor: ctx.editor, window: ctx.window)
       return true unless target
 
       deleted = ctx.buffer.span_text(y, x, target[:row], target[:col])
@@ -1194,12 +1803,14 @@ module RuVim
       true
     end
 
-    def advance_word_forward(buffer, row, col, count)
+    def advance_word_forward(buffer, row, col, count, editor: nil, window: nil)
       text = buffer.lines.join("\n")
       flat = cursor_to_offset(buffer, row, col)
       idx = flat
+      keyword_rx = keyword_char_regex(editor, buffer, window)
+      count = normalized_count(count)
       count.times do
-        idx = next_word_start_offset(text, idx)
+        idx = next_word_start_offset(text, idx, keyword_rx)
         return nil unless idx
       end
       offset_to_cursor(buffer, idx)
@@ -1209,14 +1820,14 @@ module RuVim
       buffer = ctx.buffer
       row = ctx.window.cursor_y
       col = ctx.window.cursor_x
-      count = 1 if count.to_i <= 0
+      count = normalized_count(count)
       target = { row:, col: }
       count.times do
         target =
           case kind
-          when :forward_start then advance_word_forward(buffer, target[:row], target[:col], 1)
-          when :backward_start then advance_word_backward(buffer, target[:row], target[:col], 1)
-          when :forward_end then advance_word_end(buffer, target[:row], target[:col], 1)
+          when :forward_start then advance_word_forward(buffer, target[:row], target[:col], 1, editor: ctx.editor, window: ctx.window)
+          when :backward_start then advance_word_backward(buffer, target[:row], target[:col], 1, editor: ctx.editor, window: ctx.window)
+          when :forward_end then advance_word_end(buffer, target[:row], target[:col], 1, editor: ctx.editor, window: ctx.window)
           end
         break unless target
       end
@@ -1227,60 +1838,70 @@ module RuVim
       ctx.window.clamp_to_buffer(buffer)
     end
 
-    def advance_word_backward(buffer, row, col, _count)
+    def advance_word_backward(buffer, row, col, _count, editor: nil, window: nil)
       text = buffer.lines.join("\n")
       idx = cursor_to_offset(buffer, row, col)
       idx = [idx - 1, 0].max
-      while idx > 0 && char_class(text[idx]) == :space
+      keyword_rx = keyword_char_regex(editor, buffer, window)
+      while idx > 0 && char_class(text[idx], keyword_rx) == :space
         idx -= 1
       end
-      cls = char_class(text[idx])
-      while idx > 0 && char_class(text[idx - 1]) == cls && cls != :space
+      cls = char_class(text[idx], keyword_rx)
+      while idx > 0 && char_class(text[idx - 1], keyword_rx) == cls && cls != :space
         idx -= 1
       end
-      while idx > 0 && char_class(text[idx]) == :space
+      while idx > 0 && char_class(text[idx], keyword_rx) == :space
         idx += 1
       end
       offset_to_cursor(buffer, idx)
     end
 
-    def advance_word_end(buffer, row, col, _count)
+    def advance_word_end(buffer, row, col, _count, editor: nil, window: nil)
       text = buffer.lines.join("\n")
       idx = cursor_to_offset(buffer, row, col)
       n = text.length
-      while idx < n && char_class(text[idx]) == :space
+      keyword_rx = keyword_char_regex(editor, buffer, window)
+
+      # Vim-like `e`: if already on the end of a word, move to the next word's end.
+      if idx < n
+        cur_cls = char_class(text[idx], keyword_rx)
+        next_cls = (idx + 1 < n) ? char_class(text[idx + 1], keyword_rx) : nil
+        idx += 1 if cur_cls != :space && next_cls != cur_cls
+      end
+
+      while idx < n && char_class(text[idx], keyword_rx) == :space
         idx += 1
       end
       return nil if idx >= n
 
-      cls = char_class(text[idx])
-      idx += 1 while idx + 1 < n && char_class(text[idx + 1]) == cls && cls != :space
+      cls = char_class(text[idx], keyword_rx)
+      idx += 1 while idx + 1 < n && char_class(text[idx + 1], keyword_rx) == cls && cls != :space
       offset_to_cursor(buffer, idx)
     end
 
-    def next_word_start_offset(text, from_offset)
+    def next_word_start_offset(text, from_offset, keyword_rx = nil)
       i = [from_offset, 0].max
       n = text.length
       return nil if i >= n
 
-      cls = char_class(text[i])
+      cls = char_class(text[i], keyword_rx)
       if cls == :word
-        i += 1 while i < n && char_class(text[i]) == :word
+        i += 1 while i < n && char_class(text[i], keyword_rx) == :word
       elsif cls == :space
-        i += 1 while i < n && char_class(text[i]) == :space
+        i += 1 while i < n && char_class(text[i], keyword_rx) == :space
       else
         i += 1
       end
-      i += 1 while i < n && char_class(text[i]) == :space
+      i += 1 while i < n && char_class(text[i], keyword_rx) == :space
       return n if i > n
 
       i <= n ? i : nil
     end
 
-    def char_class(ch)
+    def char_class(ch, keyword_rx = nil)
       return :space if ch == "\n"
       return :space if ch =~ /\s/
-      return :word if ch =~ /[[:alnum:]_]/
+      return :word if keyword_char?(ch, keyword_rx)
       :punct
     end
 
@@ -1306,11 +1927,12 @@ module RuVim
         x = nxt
       end
 
-      cls = line[x] =~ /[[:alnum:]_]/ ? :word : :punct
+      keyword_rx = keyword_char_regex(nil, buffer, window)
+      cls = keyword_char?(line[x], keyword_rx) ? :word : :punct
       start_col = x
-      start_col -= 1 while start_col.positive? && same_word_class?(line[start_col - 1], cls)
+      start_col -= 1 while start_col.positive? && same_word_class?(line[start_col - 1], cls, keyword_rx)
       end_col = x + 1
-      end_col += 1 while end_col < line.length && same_word_class?(line[end_col], cls)
+      end_col += 1 while end_col < line.length && same_word_class?(line[end_col], cls, keyword_rx)
 
       if around
         while end_col < line.length && line[end_col] =~ /\s/
@@ -1493,15 +2115,170 @@ module RuVim
       nil
     end
 
-    def same_word_class?(ch, cls)
+    def same_word_class?(ch, cls, keyword_rx = nil)
       return false if ch.nil?
       case cls
-      when :word then ch =~ /[[:alnum:]_]/
-      when :punct then !(ch =~ /[[:alnum:]_\s]/)
+      when :word then keyword_char?(ch, keyword_rx)
+      when :punct then !(keyword_char?(ch, keyword_rx) || ch =~ /\s/)
       else false
       end
     end
 
+    def keyword_char?(ch, keyword_rx = nil)
+      return false if ch.nil?
+
+      (keyword_rx || /[[:alnum:]_]/).match?(ch)
+    end
+
+    def keyword_char_regex(editor, buffer, window)
+      win = window || editor&.current_window
+      buf = buffer || editor&.current_buffer
+      raw =
+        if editor
+          editor.effective_option("iskeyword", window: win, buffer: buf).to_s
+        else
+          buf&.options&.fetch("iskeyword", nil).to_s
+        end
+      RuVim::KeywordChars.regex(raw)
+    end
+
+    def move_cursor_horizontally(ctx, direction:, count:)
+      count = [count.to_i, 1].max
+      allow_wrap = whichwrap_allows?(ctx, direction)
+      virtualedit_mode = virtualedit_mode(ctx)
+      count.times do
+        line = ctx.buffer.line_at(ctx.window.cursor_y)
+        if direction == :left
+          if ctx.window.cursor_x > line.length && virtualedit_mode
+            ctx.window.cursor_x -= 1
+          elsif ctx.window.cursor_x.positive?
+            ctx.window.cursor_x = RuVim::TextMetrics.previous_grapheme_char_index(line, ctx.window.cursor_x)
+          elsif allow_wrap && ctx.window.cursor_y.positive?
+            ctx.window.cursor_y -= 1
+            ctx.window.cursor_x = ctx.buffer.line_length(ctx.window.cursor_y)
+          end
+        else
+          max_right =
+            case virtualedit_mode
+            when :all then line.length + count + 1024 # practical cap; clamp below uses current cursor
+            when :onemore then line.length + 1
+            else line.length
+            end
+          if ctx.window.cursor_x < max_right
+            ctx.window.cursor_x =
+              if virtualedit_mode == :onemore && ctx.window.cursor_x == line.length
+                line.length + 1
+              elsif virtualedit_mode == :all && ctx.window.cursor_x >= line.length
+                ctx.window.cursor_x + 1
+              else
+                RuVim::TextMetrics.next_grapheme_char_index(line, ctx.window.cursor_x)
+              end
+            ctx.window.cursor_x = [ctx.window.cursor_x, max_right].min
+          elsif allow_wrap && ctx.window.cursor_y < ctx.buffer.line_count - 1
+            ctx.window.cursor_y += 1
+            ctx.window.cursor_x = 0
+          end
+        end
+      end
+      extra =
+        case virtualedit_mode
+        when :all
+          [ctx.window.cursor_x - ctx.buffer.line_length(ctx.window.cursor_y), 0].max
+        when :onemore
+          1
+        else
+          0
+        end
+      ctx.window.clamp_to_buffer(ctx.buffer, max_extra_col: extra)
+    end
+
+    def whichwrap_allows?(ctx, direction)
+      toks = ctx.editor.effective_option("whichwrap", window: ctx.window, buffer: ctx.buffer).to_s
+               .split(",").map { |s| s.strip.downcase }.reject(&:empty?)
+      return false if toks.empty?
+
+      if direction == :left
+        toks.include?("h") || toks.include?("<") || toks.include?("left")
+      else
+        toks.include?("l") || toks.include?(">") || toks.include?("right")
+      end
+    end
+
+    def virtualedit_mode(ctx)
+      spec = ctx.editor.effective_option("virtualedit", window: ctx.window, buffer: ctx.buffer).to_s
+      toks = spec.split(",").map { |s| s.strip.downcase }
+      return :all if toks.include?("all")
+      return :onemore if toks.include?("onemore")
+
+      nil
+    end
+
+    def current_view_height(ctx)
+      hint = ctx.editor.respond_to?(:current_window_view_height_hint) ? ctx.editor.current_window_view_height_hint : nil
+      [hint.to_i, 1].max
+    rescue StandardError
+      1
+    end
+
+    def current_page_step_lines(ctx)
+      [current_view_height(ctx) - 1, 1].max
+    end
+
+    def current_half_page_step_lines(ctx)
+      [current_view_height(ctx) / 2, 1].max
+    end
+
+    def scroll_window_vertically(ctx, direction:, lines:, view_height:, count:)
+      step = [[lines.to_i, 1].max * [count.to_i, 1].max, 1].max
+      height = [view_height.to_i, 1].max
+      max_row_offset = [ctx.buffer.line_count - height, 0].max
+
+      before = ctx.window.row_offset.to_i
+      after =
+        if direction == :up
+          [before - step, 0].max
+        else
+          [before + step, max_row_offset].min
+        end
+      return if after == before
+
+      ctx.window.row_offset = after
+
+      # Vim-like behavior: scroll viewport first, then keep cursor inside it.
+      top = after
+      bottom = after + height - 1
+      if ctx.window.cursor_y < top
+        ctx.window.cursor_y = top
+      elsif ctx.window.cursor_y > bottom
+        ctx.window.cursor_y = bottom
+      end
+      ctx.window.clamp_to_buffer(ctx.buffer)
+    end
+
+    def place_cursor_line_in_window(ctx, where:, count:)
+      if count
+        target_row = [[normalized_count(count) - 1, 0].max, ctx.buffer.line_count - 1].min
+        ctx.window.cursor_y = target_row
+        ctx.window.clamp_to_buffer(ctx.buffer)
+      end
+
+      height = current_view_height(ctx)
+      max_row_offset = [ctx.buffer.line_count - height, 0].max
+      desired =
+        case where
+        when :top
+          ctx.window.cursor_y
+        when :center
+          ctx.window.cursor_y - (height / 2)
+        when :bottom
+          ctx.window.cursor_y - height + 1
+        else
+          ctx.window.row_offset
+        end
+      ctx.window.row_offset = [[desired, 0].max, max_row_offset].min
+      ctx.window.clamp_to_buffer(ctx.buffer)
+    end
+
     def cursor_to_offset(buffer, row, col)
       offset = 0
       row.times { |r| offset += buffer.line_length(r) + 1 }
@@ -1537,6 +2314,7 @@ module RuVim
       lines = text.sub(/\n\z/, "").split("\n", -1)
       return if lines.empty?
 
+      count = normalized_count(count)
       insert_at = before ? ctx.window.cursor_y : (ctx.window.cursor_y + 1)
       ctx.buffer.begin_change_group
       count.times { ctx.buffer.insert_lines_at(insert_at, lines) }
@@ -1612,13 +2390,143 @@ module RuVim
       nil
     end
 
+    def normalized_count(count, default: 1)
+      n = count.nil? ? default : count.to_i
+      n = default if n <= 0
+      n
+    end
+
+    def ensure_modifiable_for_insert!(ctx)
+      raise RuVim::CommandError, "Buffer is not modifiable" unless ctx.buffer.modifiable?
+    end
+
+    def maybe_autowrite_before_switch(ctx)
+      return false unless ctx.editor.effective_option("autowrite", window: ctx.window, buffer: ctx.buffer)
+      return false unless ctx.buffer.file_buffer?
+      return false unless ctx.buffer.path && !ctx.buffer.path.empty?
+
+      ctx.buffer.write_to(ctx.buffer.path)
+      true
+    rescue StandardError
+      false
+    end
+
+    def file_token_under_cursor(buffer, window)
+      line = buffer.line_at(window.cursor_y)
+      return nil if line.empty?
+
+      x = [[window.cursor_x, 0].max, [line.length - 1, 0].max].min
+      file_char = /[[:alnum:]_\.\/~:-]/
+      if line[x] !~ file_char
+        left = x - 1
+        right = x + 1
+        if left >= 0 && line[left] =~ file_char
+          x = left
+        elsif right < line.length && line[right] =~ file_char
+          x = right
+        else
+          return nil
+        end
+      end
+
+      s = x
+      e = x + 1
+      s -= 1 while s.positive? && line[s - 1] =~ file_char
+      e += 1 while e < line.length && line[e] =~ file_char
+      line[s...e]
+    end
+
+    def parse_gf_target(token)
+      raw = token.to_s
+      if (m = /\A(.+):(\d+)\z/.match(raw))
+        return { path: m[1], line: m[2].to_i } unless m[1].end_with?(":")
+      end
+      { path: raw, line: nil }
+    end
+
+    def move_cursor_to_gf_line(ctx, line_no)
+      line = line_no.to_i
+      return if line <= 0
+
+      w = ctx.editor.current_window
+      b = ctx.editor.current_buffer
+      w.cursor_y = [line - 1, b.line_count - 1].min
+      w.cursor_x = 0
+      w.clamp_to_buffer(b)
+    end
+
+    def resolve_gf_path(ctx, token)
+      candidates = gf_candidate_paths(ctx, token.to_s)
+      candidates.find { |p| File.file?(p) || File.directory?(p) }
+    end
+
+    def gf_candidate_paths(ctx, token)
+      suffixes = gf_suffixes(ctx)
+      names = [token]
+      if File.extname(token).empty?
+        suffixes.each { |suf| names << "#{token}#{suf}" }
+      end
+      names.uniq!
+
+      if token.start_with?("/", "~/")
+        return names.map { |n| File.expand_path(n) }.uniq
+      end
+
+      base_dirs = gf_search_dirs(ctx)
+      base_dirs.product(names).map { |dir, name| File.expand_path(name, dir) }.uniq
+    end
+
+    def gf_search_dirs(ctx)
+      current_dir = if ctx.buffer.path && !ctx.buffer.path.empty?
+                      File.dirname(File.expand_path(ctx.buffer.path))
+                    else
+                      Dir.pwd
+                    end
+      raw = ctx.editor.effective_option("path", window: ctx.window, buffer: ctx.buffer).to_s
+      dirs = raw.split(",").map(&:strip).reject(&:empty?)
+      dirs = ["."] if dirs.empty?
+      dirs.flat_map do |dir|
+        expand_gf_path_entry(dir, current_dir)
+      end.uniq
+    rescue StandardError
+      [Dir.pwd]
+    end
+
+    def gf_suffixes(ctx)
+      raw = ctx.editor.effective_option("suffixesadd", window: ctx.window, buffer: ctx.buffer).to_s
+      raw.split(",").map(&:strip).reject(&:empty?).map do |s|
+        s.start_with?(".") ? s : ".#{s}"
+      end
+    end
+
+    def expand_gf_path_entry(entry, current_dir)
+      dir = entry.to_s
+      return [current_dir] if dir.empty? || dir == "."
+
+      expanded = File.expand_path(dir, current_dir)
+      if expanded.end_with?("/**")
+        base = expanded[0...-3]
+        [base, *Dir.glob(File.join(base, "**", "*"))].select { |p| File.directory?(p) }
+      elsif expanded.end_with?("**")
+        base = expanded.sub(/\*\*\z/, "")
+        base = base.sub(%r{/+\z}, "")
+        [base, *Dir.glob(File.join(base, "**", "*"))].select { |p| File.directory?(p) }
+      elsif expanded.match?(/[*?\[]/)
+        Dir.glob(expanded).select { |p| File.directory?(p) }
+      else
+        [expanded]
+      end
+    rescue StandardError
+      [expanded || File.expand_path(dir, current_dir)]
+    end
+
     def ex_set_common(ctx, argv, scope:)
       editor = ctx.editor
       if argv.empty?
         items = editor.option_snapshot(window: ctx.window, buffer: ctx.buffer).map do |opt|
           format_option_value(opt[:name], opt[:effective])
         end
-        ctx.editor.echo(items.join(" "))
+        ctx.editor.echo_multiline(items)
         return
       end
 
@@ -1766,7 +2674,235 @@ module RuVim
       ]
     end
 
+    def parse_bindings_args(argv)
+      mode_filter = nil
+      sort = "key"
+
+      Array(argv).each do |raw|
+        token = raw.to_s.strip
+        next if token.empty?
+
+        if token.include?("=")
+          key, value = token.split("=", 2).map(&:strip)
+          case key.downcase
+          when "sort"
+            sort = parse_bindings_sort(value)
+          else
+            raise RuVim::CommandError, "Unknown option for :bindings: #{key}"
+          end
+          next
+        end
+
+        raise RuVim::CommandError, "Too many positional args for :bindings" if mode_filter
+
+        mode_filter = parse_bindings_mode_filter(token)
+      end
+
+      [mode_filter, sort]
+    end
+
+    def parse_bindings_sort(raw)
+      token = raw.to_s.strip.downcase
+      case token
+      when "", "key", "keys" then "key"
+      when "command", "cmd" then "command"
+      else
+        raise RuVim::CommandError, "Unknown sort for :bindings: #{raw}"
+      end
+    end
+
+    def parse_bindings_mode_filter(raw)
+      return nil if raw.nil? || raw.to_s.strip.empty?
+
+      token = raw.to_s.strip.downcase
+      case token
+      when "n", "normal" then :normal
+      when "i", "insert" then :insert
+      when "v", "visual", "visual_char" then :visual_char
+      when "vl", "visual_line" then :visual_line
+      when "vb", "visual_block", "x" then :visual_block
+      when "o", "operator", "operator_pending" then :operator_pending
+      when "c", "cmdline", "command", "command_line" then :command_line
+      else
+        raise RuVim::CommandError, "Unknown mode for :bindings: #{raw}"
+      end
+    end
+
+    def bindings_buffer_lines(editor, entries, mode_filter:, sort:)
+      buffer = editor.current_buffer
+      filetype = buffer.options["filetype"].to_s
+      filetype = nil if filetype.empty?
+
+      lines = [
+        "Bindings",
+        "",
+        "Buffer: #{buffer.display_name}",
+        "Filetype: #{filetype || '-'}",
+        "Mode filter: #{mode_filter || 'all'}",
+        "Sort: #{sort}",
+        ""
+      ]
+
+      any = false
+      %i[buffer filetype app].each do |layer|
+        layer_entries = entries.select { |e| e.layer == layer }
+        next if layer_entries.empty?
+
+        any = true
+        lines << "Layer: #{layer}"
+        append_binding_entries_grouped!(lines, layer_entries, layer:, sort:)
+        lines << ""
+      end
+
+      lines << "(no bindings)" unless any
+      lines
+    end
+
+    def append_binding_entries_grouped!(lines, entries, layer:, sort:)
+      groups = entries.group_by do |e|
+        if layer == :app && e.scope == :global
+          [:global, nil]
+        elsif e.mode
+          [:mode, e.mode]
+        else
+          [:plain, nil]
+        end
+      end
+
+      groups.keys.sort_by { |kind, mode| binding_group_sort_key(kind, mode) }.each do |kind, mode|
+        group_entries = groups[[kind, mode]]
+        next if group_entries.nil? || group_entries.empty?
+
+        if kind == :global
+          lines << "  [global]"
+        elsif mode
+          lines << "  [#{mode}]"
+        end
+
+        group_entries = sort_binding_entries(group_entries, sort:)
+        parts = group_entries.map { |entry| binding_entry_display_parts(entry) }
+        rhs_width = parts.map { |_, rhs, _| rhs.length }.max || 0
+        parts.each do |lhs, rhs, desc|
+          lines << format_binding_entry_line(lhs, rhs, desc, rhs_width:)
+        end
+      end
+    end
+
+    def binding_group_sort_key(kind, mode)
+      rank =
+        case kind
+        when :plain then 0
+        when :mode then 1
+        when :global then 2
+        else 9
+        end
+      [rank, binding_mode_order_index(mode), mode.to_s]
+    end
+
+    def binding_mode_order_index(mode)
+      return -1 if mode.nil?
+
+      order = {
+        normal: 0,
+        insert: 1,
+        visual_char: 2,
+        visual_line: 3,
+        visual_block: 4,
+        operator_pending: 5,
+        command_line: 6
+      }
+      order.fetch(mode.to_sym, 99)
+    end
+
+    def sort_binding_entries(entries, sort:)
+      case sort.to_s
+      when "command"
+        entries.sort_by do |e|
+          [e.id.to_s, format_binding_tokens(e.tokens), e.bang ? 1 : 0, e.argv.inspect, e.kwargs.inspect]
+        end
+      else
+        entries
+      end
+    end
+
+    def binding_entry_display_parts(entry)
+      lhs = format_binding_tokens(entry.tokens)
+      rhs = entry.id.to_s
+      rhs += "!" if entry.bang
+      rhs += " argv=#{entry.argv.inspect}" unless entry.argv.nil? || entry.argv.empty?
+      rhs += " kwargs=#{entry.kwargs.inspect}" unless entry.kwargs.nil? || entry.kwargs.empty?
+      desc = binding_command_desc(entry.id)
+      [lhs, rhs, desc.to_s]
+    end
+
+    def format_binding_entry_line(lhs, rhs, desc, rhs_width:)
+      line = "    #{lhs.ljust(18)} #{rhs.ljust(rhs_width)}"
+      line += "    #{desc}" unless desc.to_s.empty?
+      line
+    end
+
+    def format_binding_tokens(tokens)
+      Array(tokens).map { |t| format_binding_token(t) }.join
+    end
+
+    def format_binding_token(token)
+      case token.to_s
+      when "\e" then "<Esc>"
+      when "\t" then "<Tab>"
+      when "\r" then "<CR>"
+      else token.to_s
+      end
+    end
+
+    def binding_command_desc(command_id)
+      RuVim::CommandRegistry.instance.fetch(command_id).desc.to_s
+    rescue StandardError
+      ""
+    end
+
+    def ex_command_binding_labels(editor, ex_spec)
+      keymaps = editor.keymap_manager
+      return [] unless keymaps
+
+      command_ids = command_ids_for_ex_callable(ex_spec.call)
+      return [] if command_ids.empty?
+
+      entries = keymaps.binding_entries_for_context(editor).select do |entry|
+        entry.layer == :app && command_ids.include?(entry.id.to_s)
+      end
+      entries.sort_by do |entry|
+        [binding_mode_order_index(entry.mode), entry.scope == :global ? 1 : 0, format_binding_tokens(entry.tokens)]
+      end.map do |entry|
+        format_ex_command_binding_label(entry)
+      end.uniq
+    end
+
+    def command_ids_for_ex_callable(callable)
+      RuVim::CommandRegistry.instance.all.filter_map do |spec|
+        spec.id if same_command_callable?(spec.call, callable)
+      end
+    end
+
+    def same_command_callable?(a, b)
+      if (a.is_a?(Symbol) || a.is_a?(String)) && (b.is_a?(Symbol) || b.is_a?(String))
+        return a.to_sym == b.to_sym
+      end
+      a.equal?(b)
+    end
+
+    def format_ex_command_binding_label(entry)
+      lhs = format_binding_tokens(entry.tokens)
+      if entry.scope == :global
+        "global:#{lhs}"
+      elsif entry.mode && entry.mode.to_sym != :normal
+        "#{entry.mode}:#{lhs}"
+      else
+        lhs
+      end
+    end
+
     def paste_charwise(ctx, text, before:, count:)
+      count = normalized_count(count)
       y = ctx.window.cursor_y
       x = ctx.window.cursor_x
       insert_col = before ? x : [x + 1, ctx.buffer.line_length(y)].min
@@ -1797,7 +2933,7 @@ module RuVim
     end
 
     def move_to_search(ctx, pattern:, direction:, count:)
-      count = 1 if count.to_i <= 0
+      count = normalized_count(count)
       regex = compile_search_regex(pattern, editor: ctx.editor, window: ctx.window, buffer: ctx.buffer)
       count.times do
         match = find_next_match(ctx.buffer, ctx.window, regex, direction: direction)
@@ -1885,5 +3021,141 @@ module RuVim
     rescue StandardError
       0
     end
+
+    def parse_substitute_flags(flags_str, default_global: false)
+      flags = { global: default_global, ignore_case: false, match_case: false, count_only: false, no_error: false, confirm: false }
+      return flags if flags_str.nil? || flags_str.empty?
+
+      flags_str.each_char do |ch|
+        case ch
+        when "g" then flags[:global] = true
+        when "i" then flags[:ignore_case] = true
+        when "I" then flags[:match_case] = true
+        when "n" then flags[:count_only] = true
+        when "e" then flags[:no_error] = true
+        when "c" then flags[:confirm] = true
+        end
+      end
+      flags
+    end
+
+    def build_substitute_regex(pattern, flags, ctx)
+      if flags[:match_case]
+        # I flag: force case-sensitive
+        Regexp.new(pattern.to_s)
+      elsif flags[:ignore_case]
+        # i flag: force case-insensitive
+        Regexp.new(pattern.to_s, Regexp::IGNORECASE)
+      else
+        compile_search_regex(pattern, editor: ctx.editor, window: ctx.window, buffer: ctx.buffer)
+      end
+    rescue RegexpError => e
+      raise RuVim::CommandError, "Invalid regex: #{e.message}"
+    end
+
+    def substitute_range(ctx, regex, replacement, r_start, r_end, flags)
+      changed = 0
+      new_lines = ctx.buffer.lines.each_with_index.map do |line, idx|
+        if idx >= r_start && idx <= r_end
+          if flags[:global]
+            line.scan(regex) { changed += 1 }
+            line.gsub(regex, replacement)
+          else
+            if line.match?(regex)
+              changed += 1
+              line.sub(regex, replacement)
+            else
+              line
+            end
+          end
+        else
+          line
+        end
+      end
+
+      if changed.positive?
+        ctx.buffer.begin_change_group
+        ctx.buffer.replace_all_lines!(new_lines)
+        ctx.buffer.end_change_group
+      end
+      changed
+    end
+
+    def count_matches_in_range(buffer, regex, r_start, r_end, global)
+      total = 0
+      (r_start..r_end).each do |idx|
+        line = buffer.line_at(idx)
+        if global
+          line.scan(regex) { total += 1 }
+        else
+          total += 1 if line.match?(regex)
+        end
+      end
+      total
+    end
+
+    public
+
+    def arglist_show(ctx, **)
+      arglist = ctx.editor.arglist
+      if arglist.empty?
+        ctx.editor.echo("No arguments")
+        return
+      end
+
+      current_index = ctx.editor.arglist_index
+      items = arglist.map.with_index do |path, i|
+        if i == current_index
+          "[#{path}]"
+        else
+          " #{path}"
+        end
+      end
+      ctx.editor.echo_multiline(items)
+    end
+
+    def arglist_next(ctx, count:, **)
+      count = normalized_count(count)
+      path = ctx.editor.arglist_next(count)
+      switch_to_file(ctx, path)
+      ctx.editor.echo("Argument #{ctx.editor.arglist_index + 1} of #{ctx.editor.arglist.length}: #{path}")
+    end
+
+    def arglist_prev(ctx, count:, **)
+      count = normalized_count(count)
+      path = ctx.editor.arglist_prev(count)
+      switch_to_file(ctx, path)
+      ctx.editor.echo("Argument #{ctx.editor.arglist_index + 1} of #{ctx.editor.arglist.length}: #{path}")
+    end
+
+    def arglist_first(ctx, **)
+      path = ctx.editor.arglist_first
+      return ctx.editor.error("No arguments") unless path
+      switch_to_file(ctx, path)
+      ctx.editor.echo("Argument 1 of #{ctx.editor.arglist.length}: #{path}")
+    end
+
+    def arglist_last(ctx, **)
+      path = ctx.editor.arglist_last
+      return ctx.editor.error("No arguments") unless path
+      switch_to_file(ctx, path)
+      ctx.editor.echo("Argument #{ctx.editor.arglist.length} of #{ctx.editor.arglist.length}: #{path}")
+    end
+
+    private
+
+    def switch_to_file(ctx, path)
+      existing_buffer = ctx.editor.buffers.values.find { |buf| buf.path == path }
+      if existing_buffer
+        ctx.editor.set_alternate_buffer_id(ctx.editor.current_buffer.id)
+        ctx.editor.activate_buffer(existing_buffer.id)
+        existing_buffer.id
+      else
+        ctx.editor.set_alternate_buffer_id(ctx.editor.current_buffer.id)
+        buffer = ctx.editor.add_buffer_from_file(path)
+        ctx.editor.current_window.buffer_id = buffer.id
+        buffer.id
+      end
+    end
   end
 end