ruvim 0.2.0 → 0.4.0

data/lib/ruvim/global_commands.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "tempfile"
 require "open3"
 
@@ -5,7 +7,7 @@ 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)
@@ -23,11 +25,11 @@ module RuVim
     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:, **)
@@ -72,6 +74,18 @@ module RuVim
       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)
@@ -91,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)
@@ -99,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
@@ -156,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 --")
@@ -180,6 +191,7 @@ 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
@@ -193,6 +205,7 @@ 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
       _new_y, new_x = ctx.buffer.insert_newline(y, 0)
@@ -250,6 +263,42 @@ module RuVim
       ctx.editor.focus_window_direction(:down)
     end
 
+    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
+    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
+        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)
@@ -258,24 +307,39 @@ module RuVim
           return
         end
       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]'}")
-      else
-        ctx.editor.echo("tab #{ctx.editor.current_tabpage_number}/#{ctx.editor.tabpage_count}")
-      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, **)
@@ -295,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
@@ -308,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) }
@@ -321,14 +458,17 @@ 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 "G" then delete_lines_to_end(ctx)
+        when "gg" then delete_lines_to_start(ctx)
         when "iw" then delete_text_object_word(ctx, around: false)
         when "aw" then delete_text_object_word(ctx, around: true)
         else
@@ -340,9 +480,22 @@ module RuVim
 
     def change_motion(ctx, count:, kwargs:, **)
       materialize_intro_buffer_if_needed(ctx)
-      handled = delete_motion(ctx, count:, kwargs:)
-      return unless handled
+      motion = (kwargs[:motion] || kwargs["motion"]).to_s
+      result = delete_motion(ctx, count:, kwargs:)
+      return unless result
 
+      if result == :linewise
+        case motion
+        when "G"
+          y = ctx.buffer.lines.length
+          ctx.buffer.insert_lines_at(y, [""])
+          ctx.window.cursor_y = y
+        when "gg"
+          ctx.buffer.insert_lines_at(0, [""])
+          ctx.window.cursor_y = 0
+        end
+        ctx.window.cursor_x = 0
+      end
       enter_insert_mode(ctx)
     end
 
@@ -433,6 +586,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?
 
@@ -453,6 +607,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)
@@ -470,6 +625,10 @@ module RuVim
         text = ctx.buffer.span_text(y, x, target[:row], target[:col])
         store_yank_register(ctx, text:, type: :charwise)
         ctx.editor.echo("yanked")
+      when "G"
+        yank_lines_to_end(ctx)
+      when "gg"
+        yank_lines_to_start(ctx)
       when "iw"
         yank_text_object_word(ctx, around: false)
       when "aw"
@@ -557,6 +716,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)
@@ -577,14 +775,38 @@ module RuVim
     end
 
     def file_write(ctx, argv:, bang:, **)
+      if ctx.buffer.kind == :git_commit
+        git_commit_execute(ctx)
+        return
+      end
+
       path = argv[0]
       target = ctx.buffer.write_to(path)
       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:, **)
+      if ctx.buffer.kind == :filter
+        saved_y = ctx.buffer.options["filter_source_cursor_y"]
+        saved_x = ctx.buffer.options["filter_source_cursor_x"]
+        saved_row_offset = ctx.buffer.options["filter_source_row_offset"]
+        saved_col_offset = ctx.buffer.options["filter_source_col_offset"]
+        ctx.editor.delete_buffer(ctx.buffer.id)
+        if saved_y
+          win = ctx.editor.current_window
+          win.cursor_y = saved_y
+          win.cursor_x = saved_x || 0
+          win.row_offset = saved_row_offset || 0
+          win.col_offset = saved_col_offset || 0
+        end
+        return
+      end
+
       if ctx.editor.window_count > 1
         ctx.editor.close_current_window
         ctx.editor.echo("closed window")
@@ -605,6 +827,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?
@@ -639,9 +880,7 @@ module RuVim
         end
       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]")
+      ctx.editor.open_path(path)
     end
 
     def file_goto_under_cursor(ctx, **)
@@ -651,9 +890,10 @@ module RuVim
         return
       end
 
-      path = resolve_gf_path(ctx, token)
+      target = parse_gf_target(token)
+      path = resolve_gf_path(ctx, target[:path])
       unless path
-        ctx.editor.echo_error("File not found: #{token}")
+        ctx.editor.echo_error("File not found: #{target[:path]}")
         return
       end
 
@@ -665,6 +905,7 @@ module RuVim
       end
 
       ctx.editor.open_path(path)
+      move_cursor_to_gf_line(ctx, target[:line]) if target[:line]
     end
 
     def buffer_list(ctx, **)
@@ -672,23 +913,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:)
@@ -768,7 +1014,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
@@ -784,8 +1030,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
 
@@ -912,14 +1167,33 @@ module RuVim
     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
@@ -942,6 +1216,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
@@ -956,6 +1231,7 @@ 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
@@ -975,6 +1251,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
 
@@ -985,6 +1262,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
 
@@ -1004,6 +1282,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
 
@@ -1014,37 +1293,152 @@ 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 rich_view_close_buffer(ctx, **)
+      ctx.editor.delete_buffer(ctx.buffer.id)
+    end
+
+    def search_filter(ctx, **)
+      editor = ctx.editor
+      search = editor.last_search
+      unless search
+        editor.echo_error("No search pattern")
+        return
+      end
+
+      regex = compile_search_regex(search[:pattern], editor: editor, window: ctx.window, buffer: ctx.buffer)
+      source_buffer = ctx.buffer
+
+      # Collect matching lines with origin mapping
+      origins = []
+      matching_lines = []
+      source_buffer.lines.each_with_index do |line, row|
+        if regex.match?(line)
+          # If source is a filter buffer, chain back to the original
+          if source_buffer.kind == :filter && source_buffer.options["filter_origins"]
+            origins << source_buffer.options["filter_origins"][row]
+          else
+            origins << { buffer_id: source_buffer.id, row: row }
+          end
+          matching_lines << line
+        end
+      end
+
+      if matching_lines.empty?
+        editor.echo_error("Pattern not found: #{search[:pattern]}")
+        return
+      end
+
+      filetype = source_buffer.options["filetype"]
+      filter_buf = editor.add_virtual_buffer(
+        kind: :filter,
+        name: "[Filter: /#{search[:pattern]}/]",
+        lines: matching_lines,
+        filetype: filetype,
+        readonly: false,
+        modifiable: false
+      )
+      filter_buf.options["filter_origins"] = origins
+      filter_buf.options["filter_source_buffer_id"] = source_buffer.id
+      filter_buf.options["filter_source_cursor_y"] = ctx.window.cursor_y
+      filter_buf.options["filter_source_cursor_x"] = ctx.window.cursor_x
+      filter_buf.options["filter_source_row_offset"] = ctx.window.row_offset
+      filter_buf.options["filter_source_col_offset"] = ctx.window.col_offset
+      editor.switch_to_buffer(filter_buf.id)
+      editor.echo("filter: #{matching_lines.length} line(s)")
+    end
+
+    def ex_filter(ctx, argv:, **)
+      if argv.any?
+        pattern = parse_vimgrep_pattern(argv.join(" "))
+        editor = ctx.editor
+        editor.set_last_search(pattern: pattern, direction: :forward)
+      end
+      search_filter(ctx)
+    end
+
     def submit_search(ctx, pattern:, direction:)
       text = pattern.to_s
       if text.empty?
@@ -1058,8 +1452,39 @@ module RuVim
       move_to_search(ctx, pattern: text, direction:, count: 1)
     end
 
+    include RuVim::Git::Handler
+
     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?
@@ -1071,6 +1496,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|
@@ -1136,6 +1625,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")
@@ -1323,6 +1828,48 @@ module RuVim
       true
     end
 
+    def delete_lines_to_end(ctx)
+      y = ctx.window.cursor_y
+      total = ctx.buffer.lines.length - y
+      deleted = ctx.buffer.line_block_text(y, total)
+      ctx.buffer.begin_change_group
+      total.times { ctx.buffer.delete_line(y) }
+      ctx.buffer.end_change_group
+      store_delete_register(ctx, text: deleted, type: :linewise)
+      ctx.window.clamp_to_buffer(ctx.buffer)
+      :linewise
+    end
+
+    def delete_lines_to_start(ctx)
+      y = ctx.window.cursor_y
+      total = y + 1
+      deleted = ctx.buffer.line_block_text(0, total)
+      ctx.buffer.begin_change_group
+      total.times { ctx.buffer.delete_line(0) }
+      ctx.buffer.end_change_group
+      store_delete_register(ctx, text: deleted, type: :linewise)
+      ctx.window.cursor_y = 0
+      ctx.window.cursor_x = 0
+      ctx.window.clamp_to_buffer(ctx.buffer)
+      :linewise
+    end
+
+    def yank_lines_to_end(ctx)
+      y = ctx.window.cursor_y
+      total = ctx.buffer.lines.length - y
+      text = ctx.buffer.line_block_text(y, total)
+      store_yank_register(ctx, text: text, type: :linewise)
+      ctx.editor.echo("#{total} line(s) yanked")
+    end
+
+    def yank_lines_to_start(ctx)
+      y = ctx.window.cursor_y
+      total = y + 1
+      text = ctx.buffer.line_block_text(0, total)
+      store_yank_register(ctx, text: text, type: :linewise)
+      ctx.editor.echo("#{total} line(s) yanked")
+    end
+
     def delete_to_end_of_line(ctx)
       y = ctx.window.cursor_y
       x = ctx.window.cursor_x
@@ -1354,22 +1901,22 @@ module RuVim
     end
 
     def delete_text_object_word(ctx, around:)
-      span = word_object_span(ctx.buffer, ctx.window, around:)
-      return false unless span
-
-      text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
-      ctx.buffer.begin_change_group
-      ctx.buffer.delete_span(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
-      ctx.buffer.end_change_group
-      store_delete_register(ctx, text:, type: :charwise) unless text.empty?
-      ctx.window.cursor_y = span[:start_row]
-      ctx.window.cursor_x = span[:start_col]
-      ctx.window.clamp_to_buffer(ctx.buffer)
-      true
+      delete_span(ctx, word_object_span(ctx.buffer, ctx.window, around:))
     end
 
     def delete_text_object(ctx, motion)
-      span = text_object_span(ctx.buffer, ctx.window, motion)
+      delete_span(ctx, text_object_span(ctx.buffer, ctx.window, motion))
+    end
+
+    def yank_text_object_word(ctx, around:)
+      yank_span(ctx, word_object_span(ctx.buffer, ctx.window, around:))
+    end
+
+    def yank_text_object(ctx, motion)
+      yank_span(ctx, text_object_span(ctx.buffer, ctx.window, motion))
+    end
+
+    def delete_span(ctx, span)
       return false unless span
 
       text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
@@ -1383,18 +1930,7 @@ module RuVim
       true
     end
 
-    def yank_text_object_word(ctx, around:)
-      span = word_object_span(ctx.buffer, ctx.window, around:)
-      return false unless span
-
-      text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
-      store_yank_register(ctx, text:, type: :charwise) unless text.empty?
-      ctx.editor.echo("yanked")
-      true
-    end
-
-    def yank_text_object(ctx, motion)
-      span = text_object_span(ctx.buffer, ctx.window, motion)
+    def yank_span(ctx, span)
       return false unless span
 
       text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
@@ -1408,6 +1944,7 @@ module RuVim
       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, keyword_rx)
         return nil unless idx
@@ -1419,7 +1956,7 @@ 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 =
@@ -1460,6 +1997,14 @@ module RuVim
       idx = cursor_to_offset(buffer, row, col)
       n = text.length
       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
@@ -1570,9 +2115,9 @@ module RuVim
       x = [window.cursor_x, line.length - 1].min
       return nil if x.negative?
 
-      left = find_left_quote(line, x, quote)
+      left = find_quote(line, x, quote, :left)
       right_from = [x, (left ? left + 1 : 0)].max
-      right = find_right_quote(line, right_from, quote)
+      right = find_quote(line, right_from, quote, :right)
       return nil unless left && right && left < right
 
       if around
@@ -1644,20 +2189,18 @@ module RuVim
       end
     end
 
-    def find_left_quote(line, x, quote)
+    def find_quote(line, x, quote, direction)
       i = x
-      while i >= 0
-        return i if line[i] == quote && !escaped?(line, i)
-        i -= 1
-      end
-      nil
-    end
-
-    def find_right_quote(line, x, quote)
-      i = x
-      while i < line.length
-        return i if line[i] == quote && !escaped?(line, i)
-        i += 1
+      if direction == :left
+        while i >= 0
+          return i if line[i] == quote && !escaped?(line, i)
+          i -= 1
+        end
+      else
+        while i < line.length
+          return i if line[i] == quote && !escaped?(line, i)
+          i += 1
+        end
       end
       nil
     end
@@ -1846,6 +2389,30 @@ module RuVim
       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 }
@@ -1881,6 +2448,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) }
@@ -1956,6 +2524,16 @@ 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?
@@ -1972,7 +2550,7 @@ module RuVim
       return nil if line.empty?
 
       x = [[window.cursor_x, 0].max, [line.length - 1, 0].max].min
-      file_char = /[[:alnum:]_\.\/~-]/
+      file_char = /[[:alnum:]_\.\/~:-]/
       if line[x] !~ file_char
         left = x - 1
         right = x + 1
@@ -1992,6 +2570,25 @@ module RuVim
       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) }
@@ -2063,7 +2660,7 @@ module RuVim
         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
 
@@ -2211,7 +2808,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
@@ -2242,7 +3067,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)
@@ -2330,5 +3155,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