kward 0.73.0 → 0.74.0

data/lib/kward/prompt_interface/editor/modes/vibe.rb

@@ -5,7 +5,7 @@ module Kward
     # Vibe-style keymap for the built-in composer file editor.
     module VibeEditorMode
       VIBE_SIMPLE_MOTION_KEYS = [
-        "w", "e", "b", "$", "0", "^", "+", "\n", "\r", "-", "_",
+        "w", "e", "b", "W", "E", "B", "$", "0", "^", "|", "+", "\n", "\r", "-", "_",
         "h", "\b", "\x7F", "j", "k", "l", " ", "{", "}"
       ].freeze
       VIBE_PAIR_TEXT_OBJECTS = {
@@ -38,6 +38,8 @@ module Kward
         csi_result = handle_vibe_csi_u_key(key)
         return csi_result unless csi_result == false
 
+        return handle_vibe_command_key(key) if @editor_state.vibe_mode == "command"
+
         tab_result = handle_tab_key_binding(key)
         return tab_result unless tab_result == false
 
@@ -46,7 +48,6 @@ module Kward
         return vibe_begin_visual_mode("visual_block") if key == TerminalKeys::CTRL_V && @editor_state.vibe_mode == "normal"
         return handle_vibe_repeat_change if key == "." && @editor_state.vibe_mode == "normal"
         return handle_vibe_search_key(key) if editor_search_active?
-        return handle_vibe_command_key(key) if @editor_state.vibe_mode == "command"
         return handle_vibe_insert_key(key) if @editor_state.vibe_mode == "insert"
         return handle_vibe_replace_key(key) if @editor_state.vibe_mode == "replace"
         return handle_vibe_visual_key(key) if vibe_visual_mode?
@@ -57,6 +58,10 @@ module Kward
       def handle_vibe_csi_u_key(key)
         sequence = parse_csi_u_key(key)
         return false unless sequence
+        if editor_search_active?
+          search_result = handle_editor_search_csi_u_key(sequence)
+          return search_result unless search_result == false
+        end
 
         code = sequence[:code]
         modifier = sequence[:modifier]
@@ -91,8 +96,12 @@ module Kward
           @editor_state.move_indentation_down
         when 107
           @editor_state.move_indentation_up
+        when 105
+          vibe_jump_forward
         when 108
           @editor_state.move_line_end
+        when 111
+          vibe_jump_backward
         when 118
           vibe_begin_visual_mode("visual_block")
         else
@@ -104,6 +113,7 @@ module Kward
         code = sequence[:code]
         text = csi_u_text(sequence)
         normalized_code = code.to_i.chr.downcase.ord rescue code
+        return "\t" if code == 9
         return "\n" if code == 13
         return "\x7F" if [8, 127].include?(code)
         return (normalized_code - 96).chr if ctrl_modifier?(sequence[:modifier]) && normalized_code.between?(97, 122)
@@ -189,6 +199,8 @@ module Kward
         when "\b", "\x7F"
           @editor_state.vibe_command = @editor_state.vibe_command[0...-1].to_s
           @editor_state.status = ":#{@editor_state.vibe_command}"
+        when "\t"
+          vibe_complete_command_path
         when "\n", "\r"
           execute_vibe_command(@editor_state.vibe_command)
         else
@@ -209,6 +221,8 @@ module Kward
           save_editor
         when /\Aw\s+(.+)\z/
           save_editor(Regexp.last_match(1))
+        when /\Ae(!?)\s+(.+)\z/
+          vibe_edit_file(Regexp.last_match(2), force: Regexp.last_match(1) == "!")
         when "run"
           vibe_record_undo { run_editor_buffer }
         when "q"
@@ -233,6 +247,81 @@ module Kward
         true
       end
 
+      def vibe_edit_file(path, force: false)
+        if @editor_state.dirty? && !force
+          @editor_state.status = "No write since last change (:e! overrides)"
+          return true
+        end
+
+        open_editor(path, allow_new: true)
+      end
+
+      def vibe_complete_command_path
+        command = @editor_state.vibe_command.to_s
+        match = command.match(/\A(e!?)\s+(.*)\z/)
+        return false unless match
+
+        prefix = match[2]
+        candidates = vibe_path_completion_candidates(prefix)
+        if candidates.empty?
+          @editor_state.status = "No matches"
+          return true
+        end
+
+        replacement = candidates.length == 1 ? candidates.first : vibe_common_prefix(candidates)
+        if replacement.length > prefix.length
+          @editor_state.vibe_command = "#{match[1]} #{replacement}"
+          @editor_state.status = ":#{@editor_state.vibe_command}"
+        elsif candidates.length > 1
+          @editor_state.status = vibe_path_completion_status(candidates)
+        end
+        true
+      end
+
+      def vibe_path_completion_candidates(prefix)
+        directory_prefix, basename_prefix = vibe_split_path_completion_prefix(prefix)
+        search_directory = File.expand_path(directory_prefix.empty? ? "." : directory_prefix, Dir.pwd)
+        root = File.expand_path(Dir.pwd)
+        return [] unless search_directory == root || search_directory.start_with?("#{root}/")
+        return [] unless File.directory?(search_directory)
+
+        Dir.children(search_directory).sort.filter_map do |entry|
+          next if entry.start_with?(".") && !basename_prefix.start_with?(".")
+          next unless entry.start_with?(basename_prefix)
+
+          path = File.join(search_directory, entry)
+          candidate = "#{directory_prefix}#{entry}"
+          File.directory?(path) ? "#{candidate}/" : candidate
+        end
+      rescue StandardError
+        []
+      end
+
+      def vibe_split_path_completion_prefix(prefix)
+        if prefix.include?(File::SEPARATOR)
+          directory = prefix[0..prefix.rindex(File::SEPARATOR)].to_s
+          basename = prefix[(prefix.rindex(File::SEPARATOR) + 1)..].to_s
+          [directory, basename]
+        else
+          ["", prefix]
+        end
+      end
+
+      def vibe_common_prefix(values)
+        return "" if values.empty?
+
+        values.reduce(values.first.dup) do |prefix, value|
+          prefix = prefix[0...-1] until value.start_with?(prefix) || prefix.empty?
+          prefix
+        end
+      end
+
+      def vibe_path_completion_status(candidates)
+        visible = candidates.first(6)
+        suffix = candidates.length > visible.length ? " …" : ""
+        "#{candidates.length} matches: #{visible.join("  ")}#{suffix}"
+      end
+
       def vibe_substitute_command(range, pattern, replacement, global: false)
         if pattern.empty?
           @editor_state.status = "Substitute pattern required"
@@ -327,7 +416,7 @@ module Kward
       end
 
       def vibe_normal_control_key?(key)
-        ["\n", "\r", "\b", "\x7F", TerminalKeys::CTRL_B, TerminalKeys::CTRL_D, TerminalKeys::CTRL_E, TerminalKeys::CTRL_F, TerminalKeys::CTRL_R, TerminalKeys::CTRL_U, TerminalKeys::CTRL_Y].include?(key)
+        ["\n", "\r", "\b", "\x7F", TerminalKeys::CTRL_B, TerminalKeys::CTRL_D, TerminalKeys::CTRL_E, TerminalKeys::CTRL_F, "\x0F", TerminalKeys::CTRL_R, TerminalKeys::CTRL_U, TerminalKeys::CTRL_Y].include?(key)
       end
 
       def vibe_visual_mode?
@@ -361,6 +450,7 @@ module Kward
       def vibe_waiting_for_more?(command)
         return true if command.match?(/\A\d+\z/) && command != "0"
         return true if command.match?(/\A\d*g\z/)
+        return true if command.match?(/\A\d*g[uU~]\z/)
         return true if command.match?(/\A\d*z\z/)
         return true if command.match?(/\A\d*[cdy]\d*\z/)
         return true if command.match?(/\A\d*[cdy]\d*[ai]\z/)
@@ -374,6 +464,7 @@ module Kward
         return true if command.match?(/\Aq\z/)
         return true if command.match?(/\A@\z/)
         return true if command.match?(/\A[\[\]]\z/)
+        return true if command.match?(/\A\d*[<>]\z/)
         return true if command.match?(/\A['`]\z/)
 
         false
@@ -393,9 +484,30 @@ module Kward
         when *VIBE_SIMPLE_MOTION_KEYS
           vibe_apply_cursor_motion(body, count)
         when "gg"
+          vibe_record_jump
           @editor_state.move_file_start
+        when "g_"
+          vibe_move_line_last_non_blank
+        when "gJ"
+          vibe_join_lines(count, command, separator: "")
+        when "ge"
+          count.times { vibe_move_to_previous_word_end }
+        when "gE"
+          count.times { vibe_move_to_previous_big_word_end }
+        when "guu"
+          vibe_transform_lines(count, :downcase, command)
+        when "gUU"
+          vibe_transform_lines(count, :upcase, command)
+        when "g~~"
+          vibe_transform_lines(count, :swapcase, command)
+        when /\Ag([uU~])(.+)\z/
+          vibe_transform_operator(Regexp.last_match(1), Regexp.last_match(2), count, command)
         when "gv"
           vibe_restore_visual_selection
+        when "`."
+          vibe_jump_to_previous_change(linewise: false)
+        when "'."
+          vibe_jump_to_previous_change(linewise: true)
         when "]m"
           vibe_jump_ruby_method(:forward)
         when "[m"
@@ -413,6 +525,7 @@ module Kward
         when /\A`(.+)\z/
           vibe_jump_to_mark(Regexp.last_match(1), linewise: false)
         when "G"
+          vibe_record_jump
           line = command.match?(/\A\d+G\z/) ? count - 1 : @editor_state.lines.length - 1
           @editor_state.set_cursor_line_and_column(line, 0)
         when "zz"
@@ -439,6 +552,8 @@ module Kward
           vibe_scroll_down
         when TerminalKeys::CTRL_Y
           vibe_scroll_up
+        when "\x0F"
+          vibe_jump_backward
         when TerminalKeys::CTRL_R
           @editor_state.redo
         when "i"
@@ -466,6 +581,8 @@ module Kward
           vibe_change_lines(count, command)
         when "J"
           vibe_join_lines(count, command)
+        when "~"
+          vibe_swapcase_characters(count, command)
         when "n"
           editor_search_repeat
         when "N"
@@ -477,7 +594,8 @@ module Kward
         when "U"
           vibe_restore_current_line
         when "%"
-          vibe_jump_to_matching_pair
+          vibe_record_jump
+          command.match?(/\A\d+%\z/) ? vibe_jump_to_file_percentage(count) : vibe_jump_to_matching_pair
         when /^([fFtT])(.?)$/
           vibe_find_character(Regexp.last_match(1), Regexp.last_match(2), count)
         when ";"
@@ -495,11 +613,9 @@ module Kward
         when "O"
           vibe_open_line_above
         when "x"
-          vibe_record_undo { count.times { @editor_state.delete_at_cursor } }
-          vibe_remember_change(command)
+          vibe_delete_characters(count, command)
         when "X"
-          vibe_record_undo { count.times { @editor_state.delete_before_cursor } }
-          vibe_remember_change(command)
+          vibe_delete_characters_before_cursor(count, command)
         when "dd"
           vibe_delete_lines(count)
           vibe_store_active_register
@@ -510,9 +626,17 @@ module Kward
         when "yy"
           vibe_yank_lines(count)
           vibe_store_active_register
+        when "Y"
+          vibe_yank_lines(count)
+          vibe_store_active_register
+        when ">>"
+          vibe_indent_lines(count, :right)
+          vibe_remember_change(command)
+        when "<<"
+          vibe_indent_lines(count, :left)
+          vibe_remember_change(command)
         when "p"
-          vibe_record_undo { @editor_state.insert(vibe_active_register_text) }
-          vibe_remember_change(original_command)
+          vibe_active_register_linewise? ? vibe_paste_line(:below, original_command) : vibe_paste_after(original_command)
         when "P"
           vibe_paste_before(original_command)
         when "u"
@@ -709,12 +833,56 @@ module Kward
         @vibe_replaying_macro = false
       end
 
+      def vibe_record_jump
+        current = @editor_state.cursor
+        return if @editor_state.vibe_jump_back_list.last == current
+
+        @editor_state.vibe_jump_back_list << current
+        @editor_state.vibe_jump_forward_list.clear
+      end
+
+      def vibe_jump_backward
+        target = @editor_state.vibe_jump_back_list.pop
+        unless target
+          @editor_state.status = "Already at oldest jump"
+          return false
+        end
+
+        @editor_state.vibe_jump_forward_list << @editor_state.cursor
+        @editor_state.cursor = [[target, 0].max, @editor_state.buffer.length].min
+        true
+      end
+
+      def vibe_jump_forward
+        target = @editor_state.vibe_jump_forward_list.pop
+        unless target
+          @editor_state.status = "Already at newest jump"
+          return false
+        end
+
+        @editor_state.vibe_jump_back_list << @editor_state.cursor
+        @editor_state.cursor = [[target, 0].max, @editor_state.buffer.length].min
+        true
+      end
+
       def vibe_set_mark(name)
         @editor_state.vibe_marks[name] = { cursor: @editor_state.cursor }
         @editor_state.status = "Set mark #{name}"
         true
       end
 
+      def vibe_jump_to_previous_change(linewise:)
+        cursor = @editor_state.vibe_previous_change_cursor
+        unless cursor
+          @editor_state.status = "Previous change not set"
+          return false
+        end
+
+        @editor_state.cursor = [[cursor, 0].max, @editor_state.buffer.length].min
+        @editor_state.move_line_first_non_blank if linewise
+        true
+      end
+
       def vibe_jump_to_mark(name, linewise:)
         mark = @editor_state.vibe_marks[name]
         unless mark
@@ -722,6 +890,7 @@ module Kward
           return false
         end
 
+        vibe_record_jump
         @editor_state.cursor = [[mark[:cursor], 0].max, @editor_state.buffer.length].min
         @editor_state.move_line_first_non_blank if linewise
         true
@@ -920,6 +1089,14 @@ module Kward
         @editor_state.move_to_line_first_non_blank(line + offset)
       end
 
+      def vibe_move_line_last_non_blank
+        line, = @editor_state.cursor_line_and_column
+        text = @editor_state.lines[line].to_s
+        column = text.rindex(/\S/) || 0
+        @editor_state.set_cursor_line_and_column(line, column)
+        true
+      end
+
       def vibe_move_to_screen_line(offset)
         target_row = @editor_state.viewport_row + offset
         if current_editor_soft_wrap?
@@ -996,14 +1173,72 @@ module Kward
         @editor_state.status = "INSERT · Esc normal"
       end
 
+      def vibe_delete_characters(count, command = nil)
+        start_index = @editor_state.cursor
+        end_index = [start_index + count, @editor_state.buffer.length].min
+        return @editor_state.status = "Empty range" if start_index == end_index
+
+        @editor_state.copy_range(start_index, end_index)
+        @editor_state.vibe_kill_linewise = false
+        vibe_record_undo { @editor_state.replace_range(start_index, end_index, "") }
+        @vibe_character_delete_for_paste = @vibe_active_register.nil?
+        vibe_store_active_register
+        vibe_remember_change(command)
+      end
+
+      def vibe_delete_characters_before_cursor(count, command = nil)
+        end_index = @editor_state.cursor
+        start_index = [end_index - count, 0].max
+        return @editor_state.status = "Empty range" if start_index == end_index
+
+        @editor_state.copy_range(start_index, end_index)
+        @editor_state.vibe_kill_linewise = false
+        vibe_record_undo { @editor_state.replace_range(start_index, end_index, "") }
+        vibe_store_active_register
+        vibe_remember_change(command)
+      end
+
+      def vibe_paste_after(command = nil)
+        return vibe_paste_line(:below, command) if vibe_active_register_linewise?
+
+        text = vibe_active_register_text
+        return false if text.empty?
+
+        vibe_record_undo do
+          @editor_state.cursor = [@editor_state.cursor + 1, @editor_state.buffer.length].min if @vibe_character_delete_for_paste
+          @editor_state.insert(text)
+        end
+        @vibe_character_delete_for_paste = false
+        vibe_remember_change(command)
+      end
+
       def vibe_paste_before(command = nil)
+        return vibe_paste_line(:above, command) if vibe_active_register_linewise?
+
         text = vibe_active_register_text
         return false if text.empty?
 
+        vibe_record_undo { @editor_state.insert(text) }
+        vibe_remember_change(command)
+      end
+
+      def vibe_paste_line(position, command = nil)
+        text = vibe_active_register_text
+        return false if text.empty?
+
+        text += "\n" unless text.end_with?("\n")
+        line, = @editor_state.cursor_line_and_column
+        target_line = position == :below ? line + 1 : line
+        insert_index = if target_line >= @editor_state.lines.length
+                         @editor_state.buffer.end_with?("\n") ? @editor_state.buffer.length : @editor_state.line_range(line)[0]
+                       else
+                         @editor_state.line_range(target_line)[0]
+                       end
         vibe_record_undo do
-          @editor_state.cursor = @editor_state.current_line_range.first if text.end_with?("\n")
+          @editor_state.cursor = insert_index
           @editor_state.insert(text)
         end
+        @editor_state.set_cursor_line_and_column(target_line, 0)
         vibe_remember_change(command)
       end
 
@@ -1030,12 +1265,29 @@ module Kward
         start_index, = @editor_state.line_range(line)
         end_line = [line + count - 1, @editor_state.lines.length - 1].min
         _, end_index = @editor_state.line_range(end_line)
-        vibe_copy_range(start_index, end_index, "Yanked #{count} line#{count == 1 ? "" : "s"}")
+        vibe_copy_range(start_index, end_index, "Yanked #{count} line#{count == 1 ? "" : "s"}", linewise: true)
+      end
+
+      def vibe_indent_lines(count, direction)
+        line, = @editor_state.cursor_line_and_column
+        end_line = [line + count - 1, @editor_state.lines.length - 1].min
+        start_index = @editor_state.line_range(line)[0]
+        end_index = @editor_state.line_range(end_line)[1]
+        original_text = @editor_state.buffer[start_index...end_index].to_s
+        lines = @editor_state.lines[line..end_line].map do |source|
+          direction == :right ? "  #{source}" : source.sub(/\A(?:  |\t| )/, "")
+        end
+        replacement = lines.join("\n")
+        replacement += "\n" if original_text.end_with?("\n")
+        vibe_record_undo { @editor_state.replace_range(start_index, end_index, replacement) }
+        @editor_state.set_cursor_line_and_column(line, 0)
+        true
       end
 
       def vibe_change_lines(count, command = nil)
         start_index, end_index = vibe_linewise_change_range(count)
         @editor_state.copy_range(start_index, end_index)
+        @editor_state.vibe_kill_linewise = true
         vibe_record_undo { @editor_state.replace_range(start_index, end_index, "") }
         @editor_state.cursor = start_index
         vibe_enter_insert_mode(command)
@@ -1080,6 +1332,17 @@ module Kward
         vibe_enter_insert_mode(command)
       end
 
+      def vibe_swapcase_characters(count, command = nil)
+        start_index = @editor_state.cursor
+        return @editor_state.status = "Empty range" if start_index >= @editor_state.buffer.length
+
+        end_index = [start_index + count, @editor_state.buffer.length].min
+        text = @editor_state.buffer[start_index...end_index].to_s.swapcase
+        vibe_record_undo { @editor_state.replace_range(start_index, end_index, text) }
+        @editor_state.cursor = [end_index, @editor_state.buffer.length].min
+        vibe_remember_change(command)
+      end
+
       def vibe_replace_single_character(character, count, command = nil)
         return @editor_state.status = "Replacement character required" if character.to_s.empty?
 
@@ -1093,7 +1356,7 @@ module Kward
         vibe_remember_change(command)
       end
 
-      def vibe_join_lines(count, command = nil)
+      def vibe_join_lines(count, command = nil, separator: nil)
         line, = @editor_state.cursor_line_and_column
         join_count = [count, 2].max
         end_line = [line + join_count - 1, @editor_state.lines.length - 1].min
@@ -1105,8 +1368,8 @@ module Kward
             next_line_start = line_end + 1
             next_line_end = next_line_start + @editor_state.lines[line + 1].to_s.length
             next_line = @editor_state.buffer[next_line_start...next_line_end].to_s.sub(/\A\s+/, "")
-            separator = next_line.empty? ? "" : " "
-            @editor_state.replace_range(line_end, next_line_end, separator + next_line)
+            join_separator = separator.nil? ? (next_line.empty? ? "" : " ") : separator
+            @editor_state.replace_range(line_end, next_line_end, join_separator + next_line)
             @editor_state.cursor = line_end
           end
         end
@@ -1119,8 +1382,42 @@ module Kward
         vibe_begin_change_recording(command) if command
       end
 
+      def vibe_transform_operator(transform_key, motion, count, command = nil)
+        motion_count, motion = vibe_count_and_body(motion)
+        count *= motion_count if motion_count.positive?
+        target = vibe_operator_target(motion, count)
+        return false unless target
+        return @editor_state.status = "Empty range" if target.start_index == target.end_index
+
+        transform = { "u" => :downcase, "U" => :upcase, "~" => :swapcase }.fetch(transform_key)
+        vibe_transform_range(target.start_index, target.end_index, transform)
+        vibe_remember_change(command)
+      end
+
+      def vibe_transform_lines(count, transform, command = nil)
+        line, = @editor_state.cursor_line_and_column
+        end_line = [line + count - 1, @editor_state.lines.length - 1].min
+        start_index = @editor_state.line_range(line)[0]
+        end_index = @editor_state.line_range(end_line)[1]
+        vibe_transform_range(start_index, end_index, transform)
+        @editor_state.set_cursor_line_and_column(line, 0)
+        vibe_remember_change(command)
+      end
+
+      def vibe_transform_range(start_index, end_index, transform)
+        text = @editor_state.buffer[start_index...end_index].to_s
+        replacement = case transform
+                      when :swapcase then text.swapcase
+                      when :downcase then text.downcase
+                      else text.upcase
+                      end
+        vibe_record_undo { @editor_state.replace_range(start_index, end_index, replacement) }
+      end
+
       def vibe_operator_motion(operator, motion, count, command = nil)
         motion_count, motion = vibe_count_and_body(motion)
+        return vibe_operator_linewise_motion(operator, motion_count, command) if motion == "G"
+
         count *= motion_count if motion_count.positive?
         return vibe_operator_linewise(operator, count, command) if motion == operator
 
@@ -1131,28 +1428,49 @@ module Kward
         vibe_apply_operator_to_target(operator, target, command, motion, count, motion_count)
       end
 
+      def vibe_operator_linewise_motion(operator, line_count, command = nil)
+        line, = @editor_state.cursor_line_and_column
+        target_line = line_count.positive? ? line_count - 1 : @editor_state.lines.length - 1
+        start_line, end_line = [line, target_line].minmax
+        start_index, = @editor_state.line_range(start_line)
+        _, end_index = @editor_state.line_range(end_line)
+        start_index -= 1 if end_index == @editor_state.buffer.length && start_index.positive?
+
+        target = VibeOperatorTarget.new(type: :linewise, start_index: start_index, end_index: end_index)
+        vibe_apply_operator_to_target(operator, target, command, "G", 1, line_count)
+      end
+
       def vibe_active_register_text
         return @editor_state.vibe_registers[@vibe_active_register].to_s if @vibe_active_register
 
         @editor_state.kill_buffer.to_s
       end
 
-      def vibe_store_active_register
+      def vibe_active_register_linewise?
+        return @editor_state.vibe_register_types[@vibe_active_register] == :linewise if @vibe_active_register
+
+        @editor_state.vibe_kill_linewise || @editor_state.kill_buffer.to_s.end_with?("\n")
+      end
+
+      def vibe_store_active_register(linewise: @editor_state.vibe_kill_linewise)
         return unless @vibe_active_register
 
         @editor_state.vibe_registers[@vibe_active_register] = @editor_state.kill_buffer.to_s
+        @editor_state.vibe_register_types[@vibe_active_register] = linewise ? :linewise : :characterwise
       end
 
       def vibe_apply_operator_to_target(operator, target, command, motion, count, motion_count)
         case operator
         when "d"
           @editor_state.copy_range(target.start_index, target.end_index)
+          @editor_state.vibe_kill_linewise = target.type == :linewise
           vibe_record_undo { @editor_state.replace_range(target.start_index, target.end_index, "") }
           @editor_state.status = "Deleted"
           vibe_store_active_register
           vibe_remember_change(command)
         when "c"
           @editor_state.copy_range(target.start_index, target.end_index)
+          @editor_state.vibe_kill_linewise = target.type == :linewise
           vibe_record_undo do
             @editor_state.replace_range(target.start_index, target.end_index, target.change_replacement_text)
             @editor_state.cursor = target.change_cursor_index
@@ -1168,7 +1486,7 @@ module Kward
 
       def vibe_operator_target(motion, count)
         return vibe_text_object_target(motion) if motion.match?(/\A[ai].\z/)
-        return vibe_word_motion_target(motion, count) if %w[w e b].include?(motion)
+        return vibe_word_motion_target(motion, count) if %w[w e b W E B ge gE].include?(motion)
         return vibe_find_motion_target(motion, count) if motion.match?(/\A[fFtT].\z/)
         return vibe_percent_motion_target if motion == "%"
 
@@ -1222,9 +1540,11 @@ module Kward
         end_index = start_index
         if motion == "w"
           end_index = vibe_word_operator_forward_index(end_index, count)
+        elsif motion == "W"
+          end_index = vibe_big_word_operator_forward_index(end_index, count)
         else
           count.times { end_index = vibe_word_motion_index(motion, end_index) }
-          end_index = [end_index + 1, @editor_state.buffer.length].min if motion == "e"
+          end_index = [end_index + 1, @editor_state.buffer.length].min if %w[e E].include?(motion)
         end
         @editor_state.cursor = end_index
         VibeOperatorTarget.new(type: :characterwise, start_index: start_index, end_index: end_index)
@@ -1251,8 +1571,18 @@ module Kward
           vibe_move_to_next_word_start
         when "e"
           vibe_move_to_word_end
-        else
+        when "b"
           vibe_move_to_previous_word_start
+        when "W"
+          vibe_move_to_next_big_word_start
+        when "E"
+          vibe_move_to_big_word_end
+        when "B"
+          vibe_move_to_previous_big_word_start
+        when "ge"
+          vibe_move_to_previous_word_end
+        else
+          vibe_move_to_previous_big_word_end
         end
         @editor_state.cursor
       ensure
@@ -1464,6 +1794,14 @@ module Kward
         cursor
       end
 
+      def vibe_jump_to_file_percentage(percent)
+        percent = [[percent, 1].max, 100].min
+        line_count = @editor_state.lines.length
+        target_line = ((line_count - 1) * percent / 100.0).floor
+        @editor_state.move_to_line_first_non_blank(target_line)
+        true
+      end
+
       def vibe_jump_to_matching_pair
         index = vibe_matching_pair_index(@editor_state.cursor)
         unless index
@@ -1632,6 +1970,12 @@ module Kward
           count.times { vibe_move_to_word_end }
         when "b"
           count.times { vibe_move_to_previous_word_start }
+        when "W"
+          count.times { vibe_move_to_next_big_word_start }
+        when "E"
+          count.times { vibe_move_to_big_word_end }
+        when "B"
+          count.times { vibe_move_to_previous_big_word_start }
         else
           return vibe_apply_motion(motion, count)
         end
@@ -1652,6 +1996,8 @@ module Kward
           @editor_state.move_line_start
         when "^"
           @editor_state.move_line_first_non_blank
+        when "|"
+          @editor_state.set_cursor_line_and_column(@editor_state.cursor_line_and_column.first, [count - 1, 0].max)
         when "+", "\n", "\r"
           vibe_move_to_relative_line_first_non_blank(count)
         when "-"
@@ -1705,6 +2051,18 @@ module Kward
         @editor_state.cursor = cursor
       end
 
+      def vibe_big_word_operator_forward_index(index, count)
+        cursor = index
+        buffer = @editor_state.buffer
+        count.times do |step|
+          cursor += 1 while cursor < buffer.length && vibe_word_kind(buffer[cursor]) != :space
+          if step < count - 1
+            cursor += 1 while cursor < buffer.length && vibe_word_kind(buffer[cursor]) == :space
+          end
+        end
+        cursor
+      end
+
       def vibe_move_to_word_end
         cursor = @editor_state.cursor
         buffer = @editor_state.buffer
@@ -1721,6 +2079,22 @@ module Kward
         @editor_state.cursor = cursor
       end
 
+      def vibe_move_to_previous_word_end
+        cursor = @editor_state.cursor
+        buffer = @editor_state.buffer
+        return if cursor.zero? || buffer.empty?
+
+        cursor = [cursor - 1, buffer.length - 1].min
+        cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor]) == :space
+        if cursor.positive? && vibe_word_kind(buffer[cursor]) != :space
+          current_kind = vibe_word_kind(buffer[cursor])
+          cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor - 1]) == current_kind
+          cursor -= 1 if cursor.positive?
+          cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor]) == :space
+        end
+        @editor_state.cursor = cursor
+      end
+
       def vibe_move_to_previous_word_start
         cursor = @editor_state.cursor
         buffer = @editor_state.buffer
@@ -1733,6 +2107,55 @@ module Kward
         @editor_state.cursor = cursor
       end
 
+      def vibe_move_to_next_big_word_start
+        cursor = @editor_state.cursor
+        buffer = @editor_state.buffer
+        return if cursor >= buffer.length
+
+        cursor += 1 while cursor < buffer.length && vibe_word_kind(buffer[cursor]) != :space
+        cursor += 1 while cursor < buffer.length && vibe_word_kind(buffer[cursor]) == :space
+        @editor_state.cursor = cursor
+      end
+
+      def vibe_move_to_big_word_end
+        cursor = @editor_state.cursor
+        buffer = @editor_state.buffer
+        return if buffer.empty? || cursor >= buffer.length
+
+        cursor += 1 if vibe_word_kind(buffer[cursor]) != :space && cursor < buffer.length - 1 && vibe_word_kind(buffer[cursor + 1]) == :space
+        cursor += 1 while cursor < buffer.length && vibe_word_kind(buffer[cursor]) == :space
+        return @editor_state.cursor = cursor if cursor >= buffer.length
+
+        cursor += 1 while cursor < buffer.length - 1 && vibe_word_kind(buffer[cursor + 1]) != :space
+        @editor_state.cursor = cursor
+      end
+
+      def vibe_move_to_previous_big_word_start
+        cursor = @editor_state.cursor
+        buffer = @editor_state.buffer
+        return if cursor.zero? || buffer.empty?
+
+        cursor -= 1
+        cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor]) == :space
+        cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor - 1]) != :space
+        @editor_state.cursor = cursor
+      end
+
+      def vibe_move_to_previous_big_word_end
+        cursor = @editor_state.cursor
+        buffer = @editor_state.buffer
+        return if cursor.zero? || buffer.empty?
+
+        cursor = [cursor - 1, buffer.length - 1].min
+        cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor]) == :space
+        if cursor.positive? && vibe_word_kind(buffer[cursor]) != :space
+          cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor - 1]) != :space
+          cursor -= 1 if cursor.positive?
+          cursor -= 1 while cursor.positive? && vibe_word_kind(buffer[cursor]) == :space
+        end
+        @editor_state.cursor = cursor
+      end
+
       def vibe_word_kind(char)
         case char.to_s
         when /\s/
@@ -1744,8 +2167,9 @@ module Kward
         end
       end
 
-      def vibe_copy_range(start_index, end_index, status)
+      def vibe_copy_range(start_index, end_index, status, linewise: false)
         @editor_state.copy_range(start_index, end_index)
+        @editor_state.vibe_kill_linewise = linewise
         @output_io.print(TerminalSequences.osc52(@editor_state.kill_buffer))
         @output_io.flush if @output_io.respond_to?(:flush)
         @editor_state.status = status
@@ -1765,6 +2189,8 @@ module Kward
       end
 
       def handle_vibe_repeat_change
+        return execute_vibe_normal_command(@editor_state.vibe_pending.to_s + ".") unless @editor_state.vibe_pending.to_s.empty?
+
         change = @editor_state.vibe_last_change
         return @editor_state.status = "No change to repeat" unless change
 
@@ -1774,6 +2200,7 @@ module Kward
 
       def vibe_begin_change_recording(command)
         @editor_state.vibe_last_change = vibe_change_keys(command)
+        @editor_state.vibe_previous_change_cursor = @editor_state.cursor
       end
 
       def vibe_record_insert_change_key(key)
@@ -1785,6 +2212,7 @@ module Kward
 
       def vibe_remember_change(command)
         @editor_state.vibe_last_change = vibe_change_keys(command) if command
+        @editor_state.vibe_previous_change_cursor = @editor_state.cursor
       end
 
       def vibe_build_change_command(operator, motion, count, motion_count)