ruvim 0.2.0 → 0.4.0

data/lib/ruvim/editor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class Editor
     OPTION_DEFS = {
@@ -45,20 +47,36 @@ module RuVim
       "expandtab" => { default_scope: :buffer, type: :bool, default: false },
       "shiftwidth" => { default_scope: :buffer, type: :int, default: 2 },
       "softtabstop" => { default_scope: :buffer, type: :int, default: 0 },
-      "autoindent" => { default_scope: :buffer, type: :bool, default: false },
-      "smartindent" => { default_scope: :buffer, type: :bool, default: false },
+      "autoindent" => { default_scope: :buffer, type: :bool, default: true },
+      "smartindent" => { default_scope: :buffer, type: :bool, default: true },
       "iskeyword" => { default_scope: :buffer, type: :string, default: nil },
       "tabstop" => { default_scope: :buffer, type: :int, default: 2 },
-      "filetype" => { default_scope: :buffer, type: :string, default: nil }
+      "filetype" => { default_scope: :buffer, type: :string, default: nil },
+      "onsavehook" => { default_scope: :buffer, type: :bool, default: true },
+      "grepprg" => { default_scope: :global, type: :string, default: "grep -nH" },
+      "grepformat" => { default_scope: :global, type: :string, default: "%f:%l:%m" }
     }.freeze
-
-    attr_reader :buffers, :windows
-    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :window_layout, :restricted_mode, :current_window_view_height_hint
+    SHEBANG_FILETYPE_RULES = [
+      [/\Aruby(?:\d+(?:\.\d+)*)?\z/, "ruby"],
+      [/\Apython(?:\d+(?:\.\d+)*)?\z/, "python"],
+      ["node", "javascript"],
+      ["nodejs", "javascript"],
+      ["deno", "javascript"],
+      ["bash", "sh"],
+      ["sh", "sh"],
+      ["zsh", "sh"],
+      ["ksh", "sh"],
+      ["dash", "sh"],
+      [/\Aperl(?:\d+(?:\.\d+)*)?\z/, "perl"]
+    ].freeze
+
+    attr_reader :buffers, :windows, :layout_tree
+    attr_accessor :current_window_id, :mode, :message, :pending_count, :alternate_buffer_id, :restricted_mode, :current_window_view_height_hint, :stdin_stream_stop_handler, :open_path_handler, :keymap_manager, :app_action_handler, :git_stream_handler, :git_stream_stop_handler
 
     def initialize
       @buffers = {}
       @windows = {}
-      @window_order = []
+      @layout_tree = nil
       @tabpages = []
       @current_tabpage_index = nil
       @next_tabpage_id = 1
@@ -68,7 +86,6 @@ module RuVim
       @current_window_id = nil
       @alternate_buffer_id = nil
       @mode = :normal
-      @window_layout = :single
       @message = ""
       @message_kind = :info
       @message_deadline = nil
@@ -76,9 +93,14 @@ module RuVim
       @restricted_mode = false
       @current_window_view_height_hint = 1
       @running = true
+      @stdin_stream_stop_handler = nil
+      @open_path_handler = nil
+      @keymap_manager = nil
+      @app_action_handler = nil
       @global_options = default_global_options
       @command_line = CommandLine.new
       @last_search = nil
+      @hlsearch_suppressed = false
       @last_find = nil
       @registers = {}
       @active_register_name = nil
@@ -89,8 +111,12 @@ module RuVim
       @macros = {}
       @macro_recording = nil
       @visual_state = nil
+      @rich_state = nil
       @quickfix_list = { items: [], index: nil }
       @location_lists = Hash.new { |h, k| h[k] = { items: [], index: nil } }
+      @arglist = []
+      @arglist_index = 0
+      @hit_enter_lines = nil
     end
 
     def running?
@@ -127,6 +153,15 @@ module RuVim
 
     def set_last_search(pattern:, direction:)
       @last_search = { pattern: pattern.to_s, direction: direction.to_sym }
+      @hlsearch_suppressed = false
+    end
+
+    def suppress_hlsearch!
+      @hlsearch_suppressed = true
+    end
+
+    def hlsearch_suppressed?
+      @hlsearch_suppressed
     end
 
     def set_last_find(char:, direction:, till:)
@@ -141,6 +176,22 @@ module RuVim
       @buffers.fetch(current_window.buffer_id)
     end
 
+    def stdin_stream_stop_or_cancel!
+      handler = @stdin_stream_stop_handler
+      return false unless handler
+
+      handler.call
+      true
+    end
+
+    def invoke_app_action(name, **kwargs)
+      handler = @app_action_handler
+      return false unless handler
+
+      handler.call(name.to_sym, **kwargs)
+      true
+    end
+
     def option_def(name)
       OPTION_DEFS[name.to_s]
     end
@@ -213,7 +264,7 @@ module RuVim
       base = File.basename(p)
       return "ruby" if %w[Gemfile Rakefile Guardfile].include?(base)
 
-      {
+      ext_ft = {
         ".rb" => "ruby",
         ".rake" => "ruby",
         ".ru" => "ruby",
@@ -225,14 +276,23 @@ module RuVim
         ".tsx" => "typescriptreact",
         ".jsx" => "javascriptreact",
         ".json" => "json",
+        ".jsonl" => "jsonl",
         ".yml" => "yaml",
         ".yaml" => "yaml",
         ".md" => "markdown",
         ".txt" => "text",
         ".html" => "html",
         ".css" => "css",
-        ".sh" => "sh"
+        ".sh" => "sh",
+        ".tsv" => "tsv",
+        ".csv" => "csv",
+        ".scm" => "scheme",
+        ".ss" => "scheme",
+        ".sld" => "scheme"
       }[File.extname(base).downcase]
+      return ext_ft if ext_ft
+
+      detect_filetype_from_shebang(p)
     end
 
     def registers
@@ -481,6 +541,53 @@ module RuVim
       end
     end
 
+    def rich_state
+      @rich_state
+    end
+
+    def rich_mode?
+      @mode == :rich
+    end
+
+    def enter_rich_mode(format:, delimiter:)
+      @mode = :rich
+      @pending_count = nil
+      @rich_state = { format: format, delimiter: delimiter }
+    end
+
+    def exit_rich_mode
+      @rich_state = nil
+      enter_normal_mode
+    end
+
+    def hit_enter_active?
+      @mode == :hit_enter
+    end
+
+    def hit_enter_lines
+      @hit_enter_lines
+    end
+
+    def enter_hit_enter_mode(lines)
+      @mode = :hit_enter
+      @hit_enter_lines = Array(lines)
+      @pending_count = nil
+    end
+
+    def exit_hit_enter_mode
+      @hit_enter_lines = nil
+      enter_normal_mode
+    end
+
+    def echo_multiline(lines)
+      lines = Array(lines)
+      if lines.length <= 1
+        echo(lines.first.to_s)
+      else
+        enter_hit_enter_mode(lines)
+      end
+    end
+
     def add_empty_buffer(path: nil)
       id = next_buffer_id
       buffer = Buffer.new(id:, path:)
@@ -492,7 +599,7 @@ module RuVim
     def add_virtual_buffer(kind:, name:, lines:, filetype: nil, readonly: true, modifiable: false)
       id = next_buffer_id
       buffer = Buffer.new(id:, lines:, kind:, name:, readonly:, modifiable:)
-      buffer.options["filetype"] = filetype if filetype
+      assign_filetype(buffer, filetype) if filetype
       @buffers[id] = buffer
       buffer
     end
@@ -509,7 +616,17 @@ module RuVim
       id = next_window_id
       window = Window.new(id:, buffer_id:)
       @windows[id] = window
-      @window_order << id
+      leaf = { type: :window, id: id }
+      if @layout_tree.nil?
+        @layout_tree = leaf
+      else
+        # Append as sibling — used for initial bootstrap only
+        if @layout_tree[:type] == :window
+          @layout_tree = { type: :hsplit, children: [@layout_tree, leaf] }
+        else
+          @layout_tree[:children] << leaf
+        end
+      end
       @current_window_id ||= id
       ensure_initial_tabpage!
       save_current_tabpage_state! unless @suspend_tab_autosave
@@ -522,15 +639,17 @@ module RuVim
       id = next_window_id
       win = Window.new(id:, buffer_id: src.buffer_id)
       @windows[id] = win
-      src_idx = @window_order.index(src.id) || (@window_order.length - 1)
-      insert_idx = (place.to_sym == :before ? src_idx : src_idx + 1)
-      @window_order.insert(insert_idx, win.id)
       ensure_initial_tabpage!
       win.cursor_x = src.cursor_x
       win.cursor_y = src.cursor_y
       win.row_offset = src.row_offset
       win.col_offset = src.col_offset
-      @window_layout = layout.to_sym
+
+      split_type = (layout.to_sym == :vertical ? :vsplit : :hsplit)
+      new_leaf = { type: :window, id: win.id }
+
+      @layout_tree = tree_split_leaf(@layout_tree, src.id, split_type, new_leaf, place.to_sym)
+
       @current_window_id = win.id
       save_current_tabpage_state! unless @suspend_tab_autosave
       win
@@ -541,18 +660,21 @@ module RuVim
     end
 
     def close_window(id)
-      return nil if @window_order.empty?
-      return nil if @window_order.length <= 1
-      return nil unless @window_order.include?(id)
+      leaves = tree_leaves(@layout_tree)
+      return nil if leaves.empty?
+      return nil if leaves.length <= 1
+      return nil unless leaves.include?(id)
 
       save_current_tabpage_state! unless @suspend_tab_autosave
-      idx = @window_order.index(id) || 0
+      idx = leaves.index(id) || 0
       @windows.delete(id)
-      @window_order.delete(id)
       @location_lists.delete(id)
-      @current_window_id = @window_order[[idx, @window_order.length - 1].min] if @current_window_id == id
-      @current_window_id ||= @window_order.first
-      @window_layout = :single if @window_order.length <= 1
+
+      @layout_tree = tree_remove(@layout_tree, id)
+
+      new_leaves = tree_leaves(@layout_tree)
+      @current_window_id = new_leaves[[idx, new_leaves.length - 1].min] if @current_window_id == id
+      @current_window_id ||= new_leaves.first
       save_current_tabpage_state! unless @suspend_tab_autosave
       current_window
     end
@@ -563,7 +685,8 @@ module RuVim
 
       save_current_tabpage_state!
       removed = @tabpages.delete_at(@current_tabpage_index)
-      Array(removed && removed[:window_order]).each do |wid|
+      removed_tree = removed && removed[:layout_tree]
+      tree_leaves(removed_tree).each do |wid|
         @windows.delete(wid)
         @location_lists.delete(wid)
       end
@@ -581,42 +704,55 @@ module RuVim
     end
 
     def focus_next_window
-      return current_window if @window_order.length <= 1
+      order = window_order
+      return current_window if order.length <= 1
 
-      idx = @window_order.index(@current_window_id) || 0
-      focus_window(@window_order[(idx + 1) % @window_order.length])
+      idx = order.index(@current_window_id) || 0
+      focus_window(order[(idx + 1) % order.length])
     end
 
     def focus_prev_window
-      return current_window if @window_order.length <= 1
+      order = window_order
+      return current_window if order.length <= 1
 
-      idx = @window_order.index(@current_window_id) || 0
-      focus_window(@window_order[(idx - 1) % @window_order.length])
+      idx = order.index(@current_window_id) || 0
+      focus_window(order[(idx - 1) % order.length])
     end
 
     def focus_window_direction(dir)
-      return current_window if @window_order.length <= 1
-
-      case @window_layout
-      when :vertical
-        if dir == :left
-          focus_prev_window
-        elsif dir == :right
-          focus_next_window
-        else
-          current_window
+      leaves = tree_leaves(@layout_tree)
+      return current_window if leaves.length <= 1
+
+      rects = tree_compute_rects(@layout_tree, top: 0.0, left: 0.0, height: 1.0, width: 1.0)
+      cur = rects[@current_window_id]
+      return current_window unless cur
+
+      best_id = nil
+      best_dist = Float::INFINITY
+      cur_cx = cur[:left] + cur[:width] / 2.0
+      cur_cy = cur[:top] + cur[:height] / 2.0
+
+      rects.each do |wid, r|
+        next if wid == @current_window_id
+        rcx = r[:left] + r[:width] / 2.0
+        rcy = r[:top] + r[:height] / 2.0
+
+        in_direction = case dir
+                       when :left  then rcx < cur_cx
+                       when :right then rcx > cur_cx
+                       when :up    then rcy < cur_cy
+                       when :down  then rcy > cur_cy
+                       end
+        next unless in_direction
+
+        dist = (rcx - cur_cx).abs + (rcy - cur_cy).abs
+        if dist < best_dist
+          best_dist = dist
+          best_id = wid
         end
-      when :horizontal
-        if dir == :up
-          focus_prev_window
-        elsif dir == :down
-          focus_next_window
-        else
-          current_window
-        end
-      else
-        focus_next_window
       end
+
+      best_id ? focus_window(best_id) : current_window
     end
 
     def switch_to_buffer(buffer_id)
@@ -634,9 +770,16 @@ module RuVim
     end
 
     def open_path(path)
+      handler = @open_path_handler
+      return handler.call(path) if handler
+
+      open_path_sync(path)
+    end
+
+    def open_path_sync(path)
       buffer = add_buffer_from_file(path)
       switch_to_buffer(buffer.id)
-      echo(path && File.exist?(path) ? "\"#{path}\" #{buffer.line_count}L" : "\"#{path}\" [New File]")
+      echo("[New File]") unless path && File.exist?(path)
       buffer
     end
 
@@ -672,7 +815,7 @@ module RuVim
       current_buffer.replace_all_lines!(intro_lines)
       current_buffer.configure_special!(kind: :intro, name: "[Intro]", readonly: true, modifiable: false)
       current_buffer.modified = false
-      current_buffer.options["filetype"] = "help"
+      assign_filetype(current_buffer, "help")
       current_window.cursor_x = 0
       current_window.cursor_y = 0
       current_window.row_offset = 0
@@ -685,7 +828,7 @@ module RuVim
       return false unless current_buffer.intro_buffer?
 
       current_buffer.become_normal_empty_buffer!
-      current_buffer.options["filetype"] = nil
+      assign_filetype(current_buffer, nil)
       current_window.cursor_x = 0
       current_window.cursor_y = 0
       current_window.row_offset = 0
@@ -745,7 +888,16 @@ module RuVim
     end
 
     def window_order
-      @window_order
+      tree_leaves(@layout_tree)
+    end
+
+    def window_layout
+      return :single if @layout_tree.nil? || @layout_tree[:type] == :window
+      case @layout_tree[:type]
+      when :vsplit then :vertical
+      when :hsplit then :horizontal
+      else :single
+      end
     end
 
     def tabpages
@@ -764,8 +916,12 @@ module RuVim
       @tabpages.length
     end
 
+    def tabpage_windows(tab)
+      tree_leaves(tab[:layout_tree])
+    end
+
     def window_count
-      @window_order.length
+      tree_leaves(@layout_tree).length
     end
 
     def quickfix_items
@@ -778,7 +934,7 @@ module RuVim
 
     def set_quickfix_list(items)
       ary = Array(items).map { |it| normalize_location(it)&.merge(text: (it[:text] || it["text"]).to_s) }.compact
-      @quickfix_list = { items: ary, index: ary.empty? ? nil : 0 }
+      @quickfix_list = { items: ary, index: nil }
       @quickfix_list
     end
 
@@ -791,7 +947,12 @@ module RuVim
       items = @quickfix_list[:items]
       return nil if items.empty?
 
-      @quickfix_list[:index] = ((@quickfix_list[:index] || 0) + step.to_i) % items.length
+      cur = @quickfix_list[:index]
+      @quickfix_list[:index] = if cur.nil?
+                                  step.to_i > 0 ? 0 : items.length - 1
+                                else
+                                  (cur + step.to_i) % items.length
+                                end
       current_quickfix_item
     end
 
@@ -814,7 +975,7 @@ module RuVim
 
     def set_location_list(items, window_id: current_window_id)
       ary = Array(items).map { |it| normalize_location(it)&.merge(text: (it[:text] || it["text"]).to_s) }.compact
-      @location_lists[window_id] = { items: ary, index: ary.empty? ? nil : 0 }
+      @location_lists[window_id] = { items: ary, index: nil }
       @location_lists[window_id]
     end
 
@@ -829,7 +990,12 @@ module RuVim
       items = list[:items]
       return nil if items.empty?
 
-      list[:index] = ((list[:index] || 0) + step.to_i) % items.length
+      cur = list[:index]
+      list[:index] = if cur.nil?
+                       step.to_i > 0 ? 0 : items.length - 1
+                     else
+                       (cur + step.to_i) % items.length
+                     end
       current_location_list_item(window_id)
     end
 
@@ -843,9 +1009,22 @@ module RuVim
       current_location_list_item(window_id)
     end
 
+    # Check if the path from root to the current window passes through
+    # a split node matching the direction's axis. Used by focus_or_split
+    # to decide whether to split or stay put at edges.
+    #   left/right → check for :vsplit ancestor
+    #   up/down    → check for :hsplit ancestor
+    def has_split_ancestor_on_axis?(dir)
+      target_type = case dir
+                    when :left, :right then :vsplit
+                    when :up, :down then :hsplit
+                    end
+      tree_path_has_split_type?(@layout_tree, @current_window_id, target_type)
+    end
+
     def find_window_ids_by_buffer_kind(kind)
       sym = kind.to_sym
-      @window_order.select do |wid|
+      window_order.select do |wid|
         win = @windows[wid]
         buf = win && @buffers[win.buffer_id]
         buf && buf.kind == sym
@@ -857,9 +1036,8 @@ module RuVim
       save_current_tabpage_state!
 
       with_tab_autosave_suspended do
-        @window_order = []
+        @layout_tree = nil
         @current_window_id = nil
-        @window_layout = :single
 
         buffer = path ? add_buffer_from_file(path) : add_empty_buffer
         add_window(buffer_id: buffer.id)
@@ -886,6 +1064,7 @@ module RuVim
       @mode = :normal
       @pending_count = nil
       clear_visual
+      @rich_state = nil
     end
 
     def enter_insert_mode
@@ -901,7 +1080,16 @@ module RuVim
 
     def cancel_command_line
       @command_line.clear
-      enter_normal_mode
+      leave_command_line
+    end
+
+    def leave_command_line
+      if @rich_state
+        @mode = :rich
+        @pending_count = nil
+      else
+        enter_normal_mode
+      end
     end
 
     def echo(msg)
@@ -974,8 +1162,69 @@ module RuVim
       command_line_active? || message_error?
     end
 
+    def assign_filetype(buffer, ft)
+      buffer.options["filetype"] = ft
+      buffer.lang_module = resolve_lang_module(ft)
+    end
+
     private
 
+    def resolve_lang_module(ft)
+      case ft
+      when "ruby" then Lang::Ruby
+      else Lang::Base
+      end
+    end
+
+    def detect_filetype_from_shebang(path)
+      line = read_first_line(path)
+      return nil unless line.start_with?("#!")
+
+      cmd = shebang_command_name(line)
+      return nil if cmd.nil? || cmd.empty?
+
+      rule = SHEBANG_FILETYPE_RULES.find do |matcher, _filetype|
+        matcher.is_a?(Regexp) ? matcher.match?(cmd) : matcher.to_s == cmd
+      end
+      rule && rule[1]
+    rescue StandardError
+      nil
+    end
+
+    def read_first_line(path)
+      return "" unless path && !path.empty?
+      return "" unless File.file?(path)
+
+      File.open(path, "rb") do |f|
+        (f.gets || "").to_s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
+    rescue StandardError
+      ""
+    end
+
+    def shebang_command_name(line)
+      src = line.to_s.sub(/\A#!/, "").strip
+      return nil if src.empty?
+
+      tokens = src.split(/\s+/)
+      return nil if tokens.empty?
+
+      prog = tokens[0].to_s
+      if File.basename(prog) == "env"
+        i = 1
+        while i < tokens.length && tokens[i].start_with?("-")
+          if tokens[i] == "-S"
+            i += 1
+            break
+          end
+          i += 1
+        end
+        prog = tokens[i].to_s
+      end
+
+      File.basename(prog.to_s)
+    end
+
     def default_global_options
       OPTION_DEFS.each_with_object({}) { |(k, v), h| h[k] = v[:default] }
     end
@@ -1033,7 +1282,7 @@ module RuVim
 
     def assign_detected_filetype(buffer)
       ft = detect_filetype(buffer.path)
-      buffer.options["filetype"] = ft if ft && !ft.empty?
+      assign_filetype(buffer, ft) if ft && !ft.empty?
       buffer
     end
 
@@ -1070,6 +1319,51 @@ module RuVim
       current_location
     end
 
+    def arglist
+      @arglist.dup
+    end
+
+    def arglist_index
+      @arglist_index
+    end
+
+    def set_arglist(paths)
+      @arglist = Array(paths).dup
+      @arglist_index = 0
+    end
+
+    def arglist_current
+      @arglist[@arglist_index] if @arglist_index < @arglist.length
+    end
+
+    def arglist_next(count = 1)
+      new_index = @arglist_index + count
+      if new_index >= @arglist.length
+        raise RuVim::CommandError, "Already at last argument"
+      end
+      @arglist_index = new_index
+      @arglist[@arglist_index]
+    end
+
+    def arglist_prev(count = 1)
+      new_index = @arglist_index - count
+      if new_index < 0
+        raise RuVim::CommandError, "Already at first argument"
+      end
+      @arglist_index = new_index
+      @arglist[@arglist_index]
+    end
+
+    def arglist_first
+      @arglist_index = 0
+      @arglist[@arglist_index] if @arglist.length > 0
+    end
+
+    def arglist_last
+      @arglist_index = [@arglist.length - 1, 0].max
+      @arglist[@arglist_index] if @arglist.length > 0
+    end
+
     private
 
     def first_nonblank_col(buffer, row)
@@ -1136,7 +1430,7 @@ module RuVim
 
     def ensure_initial_tabpage!
       return unless @tabpages.empty?
-      return if @window_order.empty?
+      return if @layout_tree.nil?
 
       @tabpages << new_tabpage_snapshot
       @current_tabpage_index = 0
@@ -1150,18 +1444,16 @@ module RuVim
     end
 
     def load_tabpage_state!(tab)
-      @window_order = tab[:window_order].dup
+      @layout_tree = tree_deep_dup(tab[:layout_tree])
       @current_window_id = tab[:current_window_id]
-      @window_layout = tab[:window_layout]
       current_window
     end
 
     def new_tabpage_snapshot(id: nil)
       {
         id: id || next_tabpage_id,
-        window_order: @window_order.dup,
-        current_window_id: @current_window_id,
-        window_layout: @window_layout
+        layout_tree: tree_deep_dup(@layout_tree),
+        current_window_id: @current_window_id
       }
     end
 
@@ -1190,5 +1482,108 @@ module RuVim
     ensure
       @suspend_tab_autosave = prev
     end
+
+    # --- Layout tree helpers ---
+
+    def tree_leaves(node)
+      return [] if node.nil?
+      return [node[:id]] if node[:type] == :window
+
+      node[:children].flat_map { |c| tree_leaves(c) }
+    end
+
+    def tree_deep_dup(node)
+      return nil if node.nil?
+      return { type: :window, id: node[:id] } if node[:type] == :window
+
+      { type: node[:type], children: node[:children].map { |c| tree_deep_dup(c) } }
+    end
+
+    # Split a leaf node into a new split node. If the parent is already the same
+    # split type, merge into the parent instead of nesting.
+    def tree_split_leaf(node, target_id, split_type, new_leaf, place)
+      if node[:type] == :window
+        if node[:id] == target_id
+          children = place == :before ? [new_leaf, node] : [node, new_leaf]
+          return { type: split_type, children: children }
+        end
+        return node
+      end
+
+      new_children = node[:children].flat_map do |child|
+        result = tree_split_leaf(child, target_id, split_type, new_leaf, place)
+        # If the child was replaced with the same split type as this node, merge
+        if result[:type] == node[:type] && result != child
+          result[:children]
+        else
+          [result]
+        end
+      end
+
+      { type: node[:type], children: new_children }
+    end
+
+    def tree_remove(node, target_id)
+      return nil if node.nil?
+      return nil if node[:type] == :window && node[:id] == target_id
+      return node if node[:type] == :window
+
+      new_children = node[:children].filter_map { |c| tree_remove(c, target_id) }
+      return nil if new_children.empty?
+      return new_children.first if new_children.length == 1
+
+      { type: node[:type], children: new_children }
+    end
+
+    # Check if the path from root to the target window passes through
+    # a split node of the given type. Returns true if any ancestor of the
+    # target window in the tree has type == split_type.
+    def tree_path_has_split_type?(node, target_id, split_type)
+      return false if node.nil?
+      return false if node[:type] == :window
+      # Check if target is in any child subtree
+      node[:children].each do |child|
+        if tree_subtree_contains?(child, target_id)
+          return true if node[:type] == split_type
+          return tree_path_has_split_type?(child, target_id, split_type)
+        end
+      end
+      false
+    end
+
+    def tree_subtree_contains?(node, target_id)
+      return false if node.nil?
+      return node[:id] == target_id if node[:type] == :window
+      node[:children].any? { |c| tree_subtree_contains?(c, target_id) }
+    end
+
+    # Compute normalized rects (0.0–1.0 coordinate space) for direction finding.
+    # Separators are ignored here — this is purely for adjacency/direction logic.
+    def tree_compute_rects(node, top:, left:, height:, width:)
+      return {} if node.nil?
+
+      if node[:type] == :window
+        return { node[:id] => { top: top, left: left, height: height, width: width } }
+      end
+
+      children = node[:children]
+      n = children.length
+      rects = {}
+
+      case node[:type]
+      when :vsplit
+        w_each = width / n.to_f
+        children.each_with_index do |child, i|
+          rects.merge!(tree_compute_rects(child, top: top, left: left + i * w_each, height: height, width: w_each))
+        end
+      when :hsplit
+        h_each = height / n.to_f
+        children.each_with_index do |child, i|
+          rects.merge!(tree_compute_rects(child, top: top + i * h_each, left: left, height: h_each, width: width))
+        end
+      end
+
+      rects
+    end
   end
 end