fatty 0.99.0 → 0.99.3

data/lib/fatty/session/shell_session.rb

@@ -3,21 +3,19 @@
 require "open3"
 
 module Fatty
-  class ShellSession < OutputSession
+  class ShellSession < Session
     action_on :session
 
-    attr_reader :field, :history
+    attr_reader :field, :history, :output_session, :on_accept
 
-    def initialize(prompt: "sh> ", on_accept: nil, completion_proc: nil, history_ctx: nil, history_path: :default)
+    def initialize(id: nil, prompt: "sh> ", on_accept: nil, completion_proc: nil, history_ctx: nil, history_path: :default)
+      keymap = Keymaps.emacs
       super(
-        keymap: Keymaps.emacs,
-        views: [
-          Fatty::OutputView.new(z: 0),
-          Fatty::InputView.new(z: 10),
-          Fatty::CursorView.new(z: 100),
-        ]
+        id: :shell,
+        keymap: keymap,
       )
       @history = Fatty::History.for_path(history_path)
+      @output_session = OutputSession.new(keymap: keymap, history: @history)
       @field = Fatty::InputField.new(
         prompt: prompt,
         history: @history,
@@ -25,165 +23,170 @@ module Fatty
         history_kind: :command,
         history_ctx: history_ctx,
       )
-
       @on_accept = on_accept
       @completion_proc = completion_proc
+      @completion_range = nil
+      @completion_path = nil
+      @completion_popup_prefix = nil
     end
 
     #########################################################################################
-    # Framework and Session Hooks
+    # Session Protocol
     #########################################################################################
 
     def init(terminal:)
       super
-      resize_output!
-      []
-    end
-
-    def keymap_contexts
-      pager_active? ? [:paging, :terminal] : [:input, :text, :terminal]
-    end
-
-    def update_key(ev)
-      return [] unless ev.is_a?(Fatty::KeyEvent)
-
-      key_str = "key=#{ev} raw=#{ev.raw}"
-      Fatty.debug("ShellSession.update_key: #{key_str}", tag: :session)
-      case ev.key
-      when :resize
-        [[:terminal, :handle_resize]]
-      when :enter, :return
-        # safety: if somehow not bound, still accept
-        submit_line
-      else
-        [alert_cmd(:warn, "Unbound key: #{ev} (edit config in 'keybindings.yml' to bind)", ev: ev)]
-      end
+      output_session.init(terminal: terminal)
+      [
+        Command.terminal(:register_session, session: output_session),
+        Command.session(output_session.id, :resize),
+      ]
+    end
+
+    def update(command)
+      log_update(command)
+      commands =
+        case command.action
+        when :terminal_paste
+          field.act_on(:paste, command.payload.fetch(:text, ""), env: action_env(event: nil))
+          []
+        when :popup_result
+          apply_popup_result(command.payload)
+        when :paste
+          text = command.payload.fetch(:text, "").to_s
+          env = action_env(event: nil)
+          field.act_on(:paste, text, env: env)
+          []
+        when :popup_tab
+          apply_completion_popup_tab(command.payload)
+        when :popup_backtab
+          apply_completion_popup_backtab(command.payload)
+        when :key
+          ev = command.payload.fetch(:event)
+          if output_session.pager_active?
+            Command.session(output_session.id, :key, event: ev)
+          elsif ev.is_a?(Fatty::KeyEvent)
+            action, args = resolve_action(ev)
+            if action
+              apply_action(action, args, event: ev)
+            else
+              case ev.key
+              when :enter, :return
+                apply_action(:submit_line, [], event: ev)
+              else
+                unrecognized_key_alert(ev)
+              end
+            end
+          else
+            []
+          end
+        else
+          []
+        end
+      Array(commands)
     end
 
-    def view(screen:, renderer:)
-      if pager_active?
-        ::Curses.curs_set(0)
-        viewport = pager_status_viewport(screen)
-        highlights = pager.search_visible_highlights(viewport: viewport)
-
-        renderer.render_output(output, viewport: viewport, highlights: highlights)
-        renderer.render_pager_field(
-          pager_field,
-          row: screen.output_rect.rows - 1,
-          role: :pager_status,
-        )
+    def view
+      Fatty.debug(
+        "ShellSession#view output_session=" \
+          "#{output_session.class}:#{output_session.object_id}",
+        tag: :render,
+      )
+      output_session.view
+      if input_suppressed?
+        renderer.clear_input_field
       else
-        ::Curses.curs_set(1)
-        renderer.render_output(output, viewport: pager_viewport, highlights: nil)
         renderer.render_input_field(field)
-        renderer.restore_cursor(field)
       end
     end
 
-    def pager_status_viewport(screen)
-      vp = pager_viewport.dup
-      vp.height = [screen.output_rect.rows - 1, 1].max
-      vp
-    end
-
-    # Save any state we want saved on quit, error, etc.
-    def persist!
-      return unless @history.respond_to?(:save!)
-
-      Fatty.debug("ShellSession#persist!: saving history", tag: :history)
-      @history.save!
-    rescue => e
-      Fatty.error("ShellSession#persist!: failed to save history: #{e.class}: #{e.message}", tag: :history)
-    end
-
-    # Called by Terminal#go on every loop iteration.
-    # Returns true if any visible state changed (dirty).
-    def tick
-      dirty = false
-      # Animated autoscroll (e.g. after M-s in paging mode).
-      if pager.autoscroll?
-        step = [(viewport.height * 3) / 4, 1].max
-        dirty ||= pager.autoscroll_step?(max_lines: step)
-      end
-      dirty
-    end
-
-    ############################################################################################
+    #########################################################################################
     # Actions
-    ############################################################################################
-
-    def action_env(event:)
-      Fatty::ActionEnvironment.new(
-        session: self,
-        counter: counter,
-        event: event,
-        buffer: @field.buffer,
-        field: @field,
-        pager: pager,
-      )
-    end
+    #########################################################################################
 
-    desc "Pass the current shell input line to the proc"
+    desc "Pass the current input line to the on_accept proc or a shell"
     action :submit_line do
-      submit_line
-    end
-
-    # Perform the on_accept action if defined, but catch a few special
-    # commands for quiting and clearing.
-    def submit_line
-      line = @field.accept_line.to_s.strip
-      return [] if line.empty?
+      line = @field.accept_line.to_s
+      return [] if line.blank? && on_accept.nil?
 
       Fatty.info("ShellSession: accept_line: #{line}")
-
       case line
       when "exit", "quit"
-        [[:terminal, :quit]]
+        Command.terminal(:quit)
       when "clear"
-        reset_output!
-        [[:send, :alert, :clear, {}]]
+        [
+          Command.session(output_session.id, :clear),
+          Command.session(:alert, :clear),
+        ]
       else
-        reset_for_command!
-        anchor = output.lines.length
-        pager.begin_command!(anchor: anchor)
+        commands = []
+        env = accept_env
+        terminal.apply_command(Command.session(output_session.id, :begin_command))
+        result = nil
+        interrupted = false
+
+        begin
+          result =
+            if @on_accept
+              @on_accept.call(line, env)
+            else
+              run_default_command(line)
+            end
+        rescue Fatty::Interrupt
+          interrupted = true
+        end
 
-        commands =
-          if @on_accept
-            @on_accept.call(line, accept_env)
-          else
-            run_default_command(line)
+        if interrupted
+          finish_interrupted_command(env)
+        else
+          commands.concat(env.commands)
+
+          if result.is_a?(String)
+            commands << Command.session(
+              output_session.id,
+              :append,
+              text: result,
+              follow: true,
+            )
+          elsif result.is_a?(Fatty::Command)
+            commands << result
+          elsif result.is_a?(Array)
+            commands.concat(result.grep(Fatty::Command))
+          elsif result
+            commands << Command.session(
+              output_session.id,
+              :append,
+              text: result.to_s,
+              follow: true,
+            )
           end
-        normalize_accept_commands(commands)
+
+          commands << Command.session(output_session.id, :finish_command)
+          commands
+        end
       end
-    rescue Errno::ENOENT
-      [[:send, :alert, :show, { level: :error, message: "Command not found (#{line})" }]]
     end
 
     desc "Accept the current shell input line and switch output to scrolling"
     action :submit_and_scroll do
-      before = output.lines.length
-      cmds = submit_line
-      pager.paging_to_scrolling if output.lines.length > before
-      cmds
+      submit_line << Command.session(output_session.id, :paging_to_scrolling)
     end
 
     desc "Interrupt scrolling, otherwise quit Fatty"
     action :interrupt do
-      if pager.mode == :scrolling
-        pager.quit_paging
-        []
+      if output_session.pager_active?
+        Command.session(output_session.id, :quit_paging)
       else
-        [[:terminal, :quit]]
+        Command.terminal(:quit)
       end
     end
 
     desc "Quit if input is empty, otherwise delete forward"
     action :interrupt_if_empty do
-      if pager.mode == :scrolling
-        pager.quit_paging
-        []
+      if output_session.pager_active?
+        Command.session(output_session.id, :quit_paging)
       elsif @field.empty?
-        [[:terminal, :quit]]
+        Command.terminal(:quit)
       else
         @field.act_on(:delete_char_forward, env: action_env(event: nil))
         []
@@ -192,147 +195,248 @@ module Fatty
 
     desc "Clear shell output"
     action :clear_output do
-      reset_output!
-      []
+      Command.session(output_session.id, :clear)
     end
 
-    desc "Cycle to the next theme"
-    action :cycle_theme do
-      [[:terminal, :cycle_theme]]
-    end
-
-    desc "Choose a theme from a popup"
-    action :choose_theme do
-      current = Fatty::Themes::Manager.current
-      names = Fatty::Themes::Manager.theme_names
-      ordered = [current] + (names - [current])
-      @theme_popup_restore = current
-
-      popup = Fatty::PopUpSession.new(
-        source: ordered,
-        kind: :theme_chooser,
-        title: "Themes",
-        prompt: "Theme: ",
-        selection: :top,
-      )
-
-      [[:terminal, :push_modal, popup]]
-    end
-
-    desc "Add a digit to the current numeric prefix"
-    action :prefix_digit do |digit|
-      counter.push_digit(digit)
+    desc "Complete the current input prefix"
+    action :complete do
+      @field.complete!
       []
     end
 
-    desc "Complete the current input prefix"
-    action :complete do
-      with_virtual_suffix_sync do
-        @field.cycle_completion!
-        []
-      end
+    desc "Complete the previous input prefix"
+    action :complete_previous do
+      @field.complete!(direction: -1)
+      []
     end
 
     desc "Open completion popup"
     action :completion_popup do
       with_virtual_suffix_sync do
         candidates = @field.popup_completion_candidates
+        completion_path = @field.popup_completion_path?
 
         if candidates.empty?
           []
         elsif candidates.length == 1
-          apply_completion(candidates.first, range: @field.popup_completion_range)
+          apply_completion(
+            candidates.first,
+            range: @field.popup_completion_range,
+            append_space: !completion_path,
+          )
         else
-          @completion_range = @field.popup_completion_range
           # NOTE: we don't pass a matcher so that the default_matcher is used.
-          popup = Fatty::PopUpSession.new(
-            source: candidates,
-            kind: :completion,
-            title: "Completions",
-            prompt: "Complete: ",
-            order: :as_given,
-            selection: :top,
-            initial_query: @field.popup_completion_query.to_s,
-          )
-          [[:terminal, :push_modal, popup]]
+          @completion_range = @field.popup_completion_range
+          @completion_path = completion_path
+          @completion_popup_prefix = completion_path ? @field.popup_completion_query.to_s : nil
+
+          completion =
+            Fatty::PopUpSession.new(
+              source: candidates,
+              kind: :completion,
+              title: completion_popup_title(@completion_popup_prefix),
+              prompt: "Complete: ",
+              order: :as_given,
+              current: :top,
+              initial_query: @field.popup_completion_query.to_s,
+              history: @history,
+              history_kind: :popup_filter,
+              history_ctx: {
+                kind: :popup_filter,
+                popup: :completion,
+                prompt: "Complete: ",
+              },
+            )
+
+          Command.terminal(:push_modal, session: completion)
         end
       end
     end
 
-    desc "Search pager forward"
-    action :pager_search_forward do
-      regex = consume_search_regex_flag
-      [[
-        :terminal,
-        :push_modal,
-        Fatty::SearchSession.new(direction: :forward, regex: regex, history: @history)
-      ]]
+    desc "Open command history search"
+    action :history_search do
+      src = ->(_q = nil) { @history.entries.select(&:command?).last(500).map(&:text) }
+      hist_searcher =
+        Fatty::PopUpSession.new(
+          source: src,
+          kind: :history_search,
+          title: "History",
+          prompt: "Narrow: ",
+          order: :as_given,
+          current: :bottom,
+          initial_query: @field.buffer.text,
+          history: @history,
+          history_kind: :popup_filter,
+          history_ctx: {
+            kind: :popup_filter,
+            popup: :history_search,
+            prompt: "Narrow: ",
+          },
+        )
+      Command.terminal(:push_modal, session: hist_searcher)
     end
 
-    desc "Search pager backward"
-    action :pager_search_backward do
-      regex = consume_search_regex_flag
-      [[
-        :terminal,
-        :push_modal,
-        Fatty::SearchSession.new(direction: :backward, regex: regex, history: @history)
-      ]]
+    #########################################################################################
+    # Other public API methods
+    #########################################################################################
+
+    # Save any state we want saved on quit, error, etc.
+    def persist!
+      return unless @history.respond_to?(:save!)
+
+      Fatty.debug("ShellSession#persist!: saving history", tag: :history)
+      @history.save!
+    rescue => e
+      Fatty.error("ShellSession#persist!: failed to save history: #{e.class}: #{e.message}", tag: :history)
     end
 
-    desc "Start incremental pager search forward"
-    action :pager_isearch_forward do
-      [[
-        :terminal,
-        :push_modal,
-        Fatty::ISearchSession.new(direction: :forward, history: @history, last_pattern: pager.search_pattern)
-      ]]
+    # Called by Terminal#go on every loop iteration.  Returns true if any
+    # visible state changed (dirty).
+    def tick
+      output_session.tick
     end
 
-    desc "Start incremental pager search backward"
-    action :pager_isearch_backward do
-      [[
-        :terminal,
-        :push_modal,
-        Fatty::ISearchSession.new(direction: :backward, history: @history, last_pattern: pager.search_pattern)
-      ]]
+    def pager_active?
+      output_session.pager_active?
     end
 
-    desc "Repeat pager search forward"
-    action :pager_search_next do
-      handle_search_result(pager.search_repeat_next!)
+    def cursor_visible?
+      !input_suppressed?
     end
 
-    desc "Repeat pager search backward"
-    action :pager_search_prev do
-      handle_search_result(pager.search_repeat_prev!)
+    private
+
+    # simplecov:disable
+
+    def input_suppressed?
+      terminal.modal_active? || output_session.pager_active?
     end
 
-    desc "Open command history search"
-    action :history_search do
-      src = ->(_q = nil) { @history.entries.select(&:command?).last(500).map(&:text) }
+    def keymap_contexts
+      [:input, :text, :terminal]
+    end
 
-      popup = Fatty::PopUpSession.new(
-        source: src,
-        kind: :history_search,
-        title: "History",
-        prompt: "I-search: ",
-        order: :as_given,
-        selection: :bottom,
-        initial_query: @field.buffer.text,
+    def apply_action(action, args, event:)
+      which =
+        if event&.respond_to?(:key)
+          event.key.inspect
+        elsif event&.respond_to?(:mouse)
+          event.mouse.inspect
+        end
+
+      Fatty.debug("ShellSession#apply_action: #{which}", tag: :keymap)
+
+      unless completion_action?(action)
+        @field.reset_completion_state!
+      end
+
+      env = action_env(event: event)
+      defn = Fatty::Actions.lookup(action)
+      result = Fatty::Actions.call(action, env, *args)
+
+      @field.sync_virtual_suffix! if defn && [:field, :buffer].include?(defn[:on])
+      normalize_action_result(result)
+    rescue Fatty::ActionError => e
+      [alert_cmd(:error, e.message, ev: event)]
+    end
+
+    def apply_popup_result(payload)
+      commands = []
+      case payload[:kind]&.to_sym
+      when :history_search
+        item = payload.fetch(:item, "").to_s
+        env = action_env(event: nil)
+        with_virtual_suffix_sync do
+          Fatty::Actions.call(:replace, env, item)
+        end
+      when :completion
+        apply_completion(
+          payload.fetch(:item, "").to_s,
+          range: @completion_range,
+          append_space: !@completion_path,
+        )
+        @completion_range = nil
+        @completion_path = nil
+        @completion_popup_prefix = nil
+      end
+      commands
+    end
+
+    def action_env(event:)
+      Fatty::ActionEnvironment.new(
+        session: self,
+        counter: counter,
+        event: event,
+        buffer: @field.buffer,
+        field: @field,
+        pager: pager,
       )
+    end
+
+    #########################################################################################
+    # Utilities
+    #########################################################################################
+
+    def pager
+      output_session.pager
+    end
+
+    def accept_env
+      CallbackEnvironment.new(terminal: terminal, output_id: output_session.id)
+    end
 
-      [[:terminal, :push_modal, popup]]
+    def run_default_command(line)
+      commands = [Command.session(output_session.id, :append, text: "$ #{line}\n", follow: true)]
+      out, status = Open3.capture2e(line)
+      if status&.exitstatus && status.exitstatus != 0
+        out << "\n[exit #{status.exitstatus}]\n"
+      end
+      commands << Command.session(output_session.id, :append, text: out, follow: true)
+    rescue Errno::ENOENT => ex
+      commands << Command.session(output_session.id, :append, text: ex.to_s, follow: true)
+    end
+
+    def unrecognized_key_alert(ev)
+      if ev.uncoded?
+        alert_cmd(
+          :error,
+          "Undefined key: #{ev.key} " \
+          "(edit config in 'keydefs.yml' to name)",
+          ev: ev,
+        )
+      else
+        alert_cmd(
+          :warn,
+          "Unbound key: #{ev} " \
+          "(edit config in 'keybindings.yml' to bind)",
+          ev: ev,
+        )
+      end
+    end
+
+    def finish_interrupted_command(env)
+      env.commands.each do |command|
+        terminal.apply_command(command)
+      end
+      terminal.apply_command(Command.session(output_session.id, :finish_command))
+      terminal.apply_command(Command.session(output_session.id, :quit_paging))
+      terminal.render_frame
+      []
     end
 
     #########################################################################################
     # Completion
     #########################################################################################
 
+    def completion_action?(action)
+      [:complete, :complete_previous].include?(action.to_sym)
+    end
+
     def completion_candidates
       path_candidates = @field.path_completion_candidates
       return path_candidates if path_candidates.any?
 
-      return [] unless @completion_proc
+      return [] unless @completion_pr
 
       prefix = completion_prefix
       Array(@completion_proc.call(@field.buffer))
@@ -381,7 +485,25 @@ module Fatty
       commands
     end
 
-    def apply_completion(candidate, range: nil)
+    def completion_path_item?(item)
+      item.to_s.end_with?("/")
+    end
+
+    def parent_completion_path(path)
+      s = path.to_s
+      return if s.empty?
+
+      s = s[0...-1] if s.end_with?("/") && s.length > 1
+      slash = s.rindex("/")
+      return unless slash
+
+      parent = s[0..slash]
+      return if parent == path
+
+      parent
+    end
+
+    def apply_completion(candidate, range: nil, append_space: true)
       candidate = candidate.to_s
       return [] if candidate.empty?
 
@@ -389,153 +511,63 @@ module Fatty
       target = range || buffer.completion_replace_range
       old_text = buffer.text.dup
       old_end = target.end
-      append_space =
+
+      should_append_space =
+        append_space &&
         !candidate.match?(/\s\z/) &&
         (old_end >= old_text.length || old_text[old_end]&.match?(/\s/))
-      inserted = append_space ? "#{candidate} " : candidate
+
+      inserted = should_append_space ? "#{candidate} " : candidate
       buffer.replace_range(target, inserted)
+      buffer.virtual_suffix = ""
       []
     end
 
-    private
+    def apply_completion_popup_tab(payload)
+      return [] unless @completion_path
 
-    def accept_env
-      Fatty::AcceptEnv.new(session: self)
-    end
+      popup = payload[:session]
+      item = payload[:item].to_s
+      return [] unless popup
+      return [] unless completion_path_item?(item)
 
-    def normalize_accept_commands(commands)
-      if commands.is_a?(Array) && commands.first.is_a?(Array) && commands.first.first.is_a?(Symbol)
-        commands
-      else
-        [[:send, :alert, :clear, {}]]
-      end
+      replace_completion_popup_path(popup, item)
     end
 
-    def update_cmd(name, payload)
-      cmds = []
-      case name
-      when :popup_result
-        case payload[:kind]&.to_sym
-        when :history_search
-          item = payload.fetch(:item, "").to_s
-          env = action_env(event: nil)
-          with_virtual_suffix_sync do
-            Fatty::Actions.call(:replace, env, item)
-          end
-        when :theme_chooser
-          theme = payload.fetch(:item).to_sym
-          @theme_popup_restore = nil
-          cmds << [:terminal, :set_theme, theme]
-          cmds << [:send, :alert, :show, { level: :info, message: "Theme: #{theme}" }]
-        when :completion
-          apply_completion(payload.fetch(:item, "").to_s, range: @completion_range)
-          @completion_range = nil
-        end
-      when :popup_changed
-        if payload[:kind]&.to_sym == :theme_chooser
-          theme = payload.fetch(:item).to_sym
-          cmds << [:terminal, :set_theme, theme]
-        end
-      when :popup_cancelled
-        if payload[:kind]&.to_sym == :theme_chooser && @theme_popup_restore
-          cmds << [:terminal, :set_theme, @theme_popup_restore]
-          @theme_popup_restore = nil
-        end
-      when :pager_search_set
-        pattern = payload.fetch(:pattern, "").to_s
-        regex = !!payload[:regex]
-        direction = (payload[:direction] || :forward).to_sym
-        result = pager.search_set!(pattern: pattern, regex: regex, direction: direction)
-        cmds.concat(handle_search_result(result))
-      when :pager_search_step
-        direction = (payload[:direction] || :forward).to_sym
-        result = pager.search_step!(direction: direction)
-        cmds.concat(handle_search_result(result))
-      when :pager_isearch_update
-        pattern = payload.fetch(:pattern, "").to_s
-        direction = (payload[:direction] || :forward).to_sym
-        result = pager.isearch_update!(pattern: pattern, direction: direction)
-        cmds.concat(handle_search_result(result))
-        cmds << [:send, :isearch, :isearch_set_failed, { failed: result[:status] != :moved }]
-      when :pager_isearch_step
-        direction = (payload[:direction] || :forward).to_sym
-        result = pager.isearch_step!(direction: direction)
-        cmds.concat(handle_search_result(result))
-        cmds << [:send, :isearch, :isearch_set_failed, { failed: result[:status] != :moved }]
-      when :pager_isearch_cancel
-        pager.isearch_cancel!
-        cmds << [:send, :isearch, :isearch_set_failed, { failed: false }]
-      when :pager_isearch_commit
-        pattern = payload.fetch(:pattern, "").to_s
-        direction = (payload[:direction] || :forward).to_sym
-        result = pager.isearch_commit!(pattern: pattern, direction: direction)
-        cmds.concat(handle_search_result(result))
-        cmds << [:send, :isearch, :isearch_set_failed, { failed: false }]
-      when :paste
-        text = payload.fetch(:text, "").to_s
-        env = action_env(event: nil)
-        field.act_on(:paste, text, env: env)
-      end
-      cmds
-    end
+    def apply_completion_popup_backtab(payload)
+      return [] unless @completion_path
 
-    def handle_action(action, args, event:)
-      which =
-        if event&.respond_to?(:key)
-          event.key.inspect
-        elsif event&.respond_to?(:mouse)
-          event.mouse.inspect
-        end
-      Fatty.debug("ShellSession#handle_action: #{which}", tag: :keymap)
-      env = action_env(event: event)
-      apply_action(action, args, event, env: env)
-    end
+      popup = payload[:session]
+      return [] unless popup
 
-    # Centralized dispatch: actions declare their target (:buffer/:field/:pager)
-    # and Fatty::Actions routes through ActionEnvironment.
-    def apply_action(action, args, ev, env:)
-      @field.reset_completion_cycle!
-      defn = Fatty::Actions.lookup(action)
-      result = Fatty::Actions.call(action, env, *args)
-      if defn && [:field, :buffer].include?(defn[:on])
-        @field.sync_virtual_suffix!
-      end
-      result.is_a?(Array) ? result : []
-    rescue Fatty::ActionError => e
-      [alert_cmd(:error, e.message, ev: ev)]
-    end
+      path = @completion_popup_prefix || payload[:query].to_s
+      path = payload[:item].to_s if path.empty?
 
-    def run_default_command(line)
-      append_output("$ #{line}\n", follow: true)
-      out, status = Open3.capture2e(line)
-      # optional: include exit status line
-      out << "\n[exit #{status.exitstatus}]\n" if status&.exitstatus && status.exitstatus != 0
-      out
-    rescue Errno::ENOENT
-      "Command not found: #{line}\n"
-    end
-
-    def consume_search_regex_flag
-      regex = false
-      if counter.digits.to_s == "4"
-        regex = true
-        counter.clear!
-      end
-      regex
+      parent = parent_completion_path(path)
+      return [] unless parent
+
+      replace_completion_popup_path(popup, parent)
     end
 
-    def handle_search_result(result)
-      return unless result.is_a?(Hash)
+    def replace_completion_popup_path(popup, prefix)
+      @completion_popup_prefix = prefix.to_s
+      candidates = @field.path_completion_candidates_for(@completion_popup_prefix)
+
+      popup.replace_source(
+        source: candidates,
+        title: completion_popup_title(@completion_popup_prefix),
+        query: "",
+        current: :top,
+      )
+
+      []
+    end
 
-      case result[:status]
-      when :boundary
-        msg = result[:message].to_s
-        msg = "Search reached boundary" if msg.empty?
-        [[:send, :alert, :show, { level: :info, message: msg }]]
-      when :not_found
-        [[:send, :alert, :show, { level: :info, message: "No matches" }]]
+    def completion_popup_title(prefix = nil)
+      if prefix && !prefix.empty?
+        "Completions: #{prefix}"
       else
-        []
+        "Completions"
       end
     end
 
@@ -545,22 +577,5 @@ module Fatty
       @field.sync_virtual_suffix!
       result
     end
-
-    def alert_cmd(level, message, ev: nil)
-      details =
-        if ev
-          {
-            key: ev.key,
-            ctrl: ev.respond_to?(:ctrl?) ? ev.ctrl? : ev.ctrl,
-            meta: ev.respond_to?(:meta?) ? ev.meta? : ev.meta,
-            shift: ev.respond_to?(:shift?) ? ev.shift? : ev.shift,
-            text: ev.text
-          }
-        else
-          {}
-        end
-
-      [:send, :alert, :show, { level: level, message: message, details: details }]
-    end
   end
 end