try-cli 1.7.1

data/try.rb

@@ -0,0 +1,1281 @@
+#!/usr/bin/env ruby
+
+require 'io/console'
+require 'time'
+require 'fileutils'
+require_relative 'lib/tui'
+require_relative 'lib/fuzzy'
+
+class TrySelector
+  include Tui::Helpers
+  TRY_PATH = ENV['TRY_PATH'] || File.expand_path("~/src/tries")
+
+  def initialize(search_term = "", base_path: TRY_PATH, initial_input: nil, test_render_once: false, test_no_cls: false, test_keys: nil, test_confirm: nil)
+    @search_term = search_term.gsub(/\s+/, '-')
+    @cursor_pos = 0  # Navigation cursor (list position)
+    @input_cursor_pos = 0  # Text cursor (position within search buffer)
+    @scroll_offset = 0
+    @input_buffer = initial_input ? initial_input.gsub(/\s+/, '-') : @search_term
+    @input_cursor_pos = @input_buffer.length  # Start at end of buffer
+    @selected = nil
+    @all_trials = nil  # Memoized trials
+    @base_path = base_path
+    @delete_status = nil  # Status message for deletions
+    @delete_mode = false  # Whether we're in deletion mode
+    @marked_for_deletion = []  # Paths marked for deletion
+    @test_render_once = test_render_once
+    @test_no_cls = test_no_cls
+    @test_keys = test_keys
+    @test_had_keys = test_keys && !test_keys.empty?
+    @test_confirm = test_confirm
+    @old_winch_handler = nil  # Store original SIGWINCH handler
+    @needs_redraw = false
+
+    FileUtils.mkdir_p(@base_path) unless Dir.exist?(@base_path)
+  end
+
+  def run
+    # Always use STDERR for rendering (it stays connected to TTY)
+    # This allows stdout to be captured for the shell commands
+    setup_terminal
+
+    # In test mode with no keys, render once and exit without TTY requirements
+    # If test_keys are provided, run the full loop
+    if @test_render_once && (@test_keys.nil? || @test_keys.empty?)
+      tries = get_tries
+      render(tries)
+      return nil
+    end
+
+    # Check if we have a TTY; allow tests with injected keys
+    if !STDIN.tty? || !STDERR.tty?
+      if @test_keys.nil? || @test_keys.empty?
+        STDERR.puts "Error: try requires an interactive terminal"
+        return nil
+      end
+      main_loop
+    else
+      STDERR.raw do
+        main_loop
+      end
+    end
+  ensure
+    restore_terminal
+  end
+
+  private
+
+  def setup_terminal
+    unless @test_no_cls
+      # Switch to alternate screen buffer (like vim, less, etc.)
+      STDERR.print(Tui::ANSI::ALT_SCREEN_ON)
+      STDERR.print(Tui::ANSI::CLEAR_SCREEN)
+      STDERR.print(Tui::ANSI::HOME)
+      STDERR.print(Tui::ANSI::CURSOR_BLINK)
+    end
+
+    @old_winch_handler = Signal.trap('WINCH') { @needs_redraw = true }
+  end
+
+  def restore_terminal
+    unless @test_no_cls
+      STDERR.print(Tui::ANSI::RESET)
+      STDERR.print(Tui::ANSI::CURSOR_DEFAULT)
+      # Return to main screen buffer
+      STDERR.print(Tui::ANSI::ALT_SCREEN_OFF)
+    end
+
+    Signal.trap('WINCH', @old_winch_handler) if @old_winch_handler
+  end
+
+  def load_all_tries
+    # Load trials only once - single pass through directory
+    @all_tries ||= begin
+      tries = []
+      now = Time.now
+      Dir.foreach(@base_path) do |entry|
+        # exclude . and .. but also .git, and any other hidden dirs.
+        next if entry.start_with?('.')
+
+        path = File.join(@base_path, entry)
+        stat = File.stat(path)
+
+        # Only include directories
+        next unless stat.directory?
+
+        # Compute base_score from recency + date prefix bonus
+        mtime = stat.mtime
+        hours_since_access = (now - mtime) / 3600.0
+        base_score = 3.0 / Math.sqrt(hours_since_access + 1)
+
+        # Bonus for date-prefixed directories
+        base_score += 2.0 if entry.match?(/^\d{4}-\d{2}-\d{2}-/)
+
+        tries << {
+          text: entry,
+          basename: entry,
+          path: path,
+          is_new: false,
+          ctime: stat.ctime,
+          mtime: mtime,
+          base_score: base_score
+        }
+      end
+      tries
+    end
+  end
+
+  # Result wrapper to avoid Hash#merge allocation per entry
+  TryEntry = Data.define(:data, :score, :highlight_positions) do
+    def [](key)
+      case key
+      when :score then score
+      when :highlight_positions then highlight_positions
+      else data[key]
+      end
+    end
+
+    def method_missing(name, *)
+      data[name]
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      data.key?(name) || super
+    end
+  end
+
+  def get_tries
+    load_all_tries
+    @fuzzy ||= Fuzzy.new(@all_tries)
+
+    results = []
+    @fuzzy.match(@input_buffer).each do |entry, positions, score|
+      results << TryEntry.new(entry, score, positions)
+    end
+    results
+  end
+
+  def main_loop
+    loop do
+      tries = get_tries
+      show_create_new = !@input_buffer.empty?
+      total_items = tries.length + (show_create_new ? 1 : 0)
+
+      # Ensure cursor is within bounds
+      @cursor_pos = [[@cursor_pos, 0].max, [total_items - 1, 0].max].min
+
+      render(tries)
+
+      key = read_key
+      # nil means terminal resize - just re-render with new dimensions
+      next unless key
+
+      case key
+      when "\r"  # Enter (carriage return)
+        if @delete_mode && !@marked_for_deletion.empty?
+          # Confirm deletion of marked items
+          confirm_batch_delete(tries)
+          break if @selected
+        elsif @cursor_pos < tries.length
+          handle_selection(tries[@cursor_pos])
+          break if @selected
+        elsif show_create_new
+          # Selected "Create new"
+          handle_create_new
+          break if @selected
+        end
+      when "\e[A", "\x10"  # Up arrow or Ctrl-P
+        @cursor_pos = [@cursor_pos - 1, 0].max
+      when "\e[B", "\x0E"  # Down arrow or Ctrl-N
+        @cursor_pos = [@cursor_pos + 1, total_items - 1].min
+      when "\e[C"  # Right arrow - ignore
+        # Do nothing
+      when "\e[D"  # Left arrow - ignore
+        # Do nothing
+      when "\x7F", "\b"  # Backspace
+        if @input_cursor_pos > 0
+          @input_buffer = @input_buffer[0...(@input_cursor_pos-1)] + @input_buffer[@input_cursor_pos..-1]
+          @input_cursor_pos -= 1
+        end
+        @cursor_pos = 0  # Reset list selection when typing
+      when "\x01"  # Ctrl-A - beginning of line
+        @input_cursor_pos = 0
+      when "\x05"  # Ctrl-E - end of line
+        @input_cursor_pos = @input_buffer.length
+      when "\x02"  # Ctrl-B - backward char
+        @input_cursor_pos = [@input_cursor_pos - 1, 0].max
+      when "\x06"  # Ctrl-F - forward char
+        @input_cursor_pos = [@input_cursor_pos + 1, @input_buffer.length].min
+      when "\x08"  # Ctrl-H - backward delete char (same as backspace)
+        if @input_cursor_pos > 0
+          @input_buffer = @input_buffer[0...(@input_cursor_pos-1)] + @input_buffer[@input_cursor_pos..-1]
+          @input_cursor_pos -= 1
+        end
+        @cursor_pos = 0
+      when "\x0B"  # Ctrl-K - kill to end of line
+        @input_buffer = @input_buffer[0...@input_cursor_pos]
+      when "\x17"  # Ctrl-W - delete word backward (alphanumeric)
+        if @input_cursor_pos > 0
+          # Start from cursor position and move backward
+          pos = @input_cursor_pos - 1
+
+          # Skip trailing non-alphanumeric
+          while pos >= 0 && @input_buffer[pos] !~ /[a-zA-Z0-9]/
+            pos -= 1
+          end
+
+          # Skip backward over alphanumeric chars
+          while pos >= 0 && @input_buffer[pos] =~ /[a-zA-Z0-9]/
+            pos -= 1
+          end
+
+          # Delete from pos+1 to cursor
+          new_pos = pos + 1
+          @input_buffer = @input_buffer[0...new_pos] + @input_buffer[@input_cursor_pos..-1]
+          @input_cursor_pos = new_pos
+        end
+      when "\x04"  # Ctrl-D - toggle mark for deletion
+        if @cursor_pos < tries.length
+          path = tries[@cursor_pos][:path]
+          if @marked_for_deletion.include?(path)
+            @marked_for_deletion.delete(path)
+          else
+            @marked_for_deletion << path
+            @delete_mode = true
+          end
+          # Exit delete mode if no more marks
+          @delete_mode = false if @marked_for_deletion.empty?
+        end
+      when "\x14"  # Ctrl-T - create new try (immediate)
+        handle_create_new
+        break if @selected
+      when "\x12"  # Ctrl-R - rename selected entry
+        if @cursor_pos < tries.length
+          run_rename_dialog(tries[@cursor_pos])
+          break if @selected
+        end
+      when "\x03", "\e"  # Ctrl-C or ESC
+        if @delete_mode
+          # Exit delete mode, clear marks
+          @marked_for_deletion.clear
+          @delete_mode = false
+        else
+          @selected = nil
+          break
+        end
+      when String
+        # Only accept printable characters, not escape sequences
+        if key.length == 1 && key =~ /[a-zA-Z0-9\-\_\. ]/
+          @input_buffer = @input_buffer[0...@input_cursor_pos] + key + @input_buffer[@input_cursor_pos..-1]
+          @input_cursor_pos += 1
+          @cursor_pos = 0  # Reset list selection when typing
+        end
+      end
+    end
+
+    @selected
+  end
+
+  def read_key
+    if @test_keys && !@test_keys.empty?
+      return @test_keys.shift
+    end
+    # In test mode with no more keys, auto-exit by returning ESC
+    return "\e" if @test_had_keys && @test_keys && @test_keys.empty?
+
+    # Use IO.select with timeout to allow checking for resize
+    loop do
+      if @needs_redraw
+        @needs_redraw = false
+        clear_screen unless @test_no_cls
+        return nil
+      end
+      ready = IO.select([STDIN], nil, nil, 0.1)
+      return read_keypress if ready
+    end
+  end
+
+  def read_keypress
+    input = STDIN.getc
+    return nil if input.nil?
+
+    if input == "\e"
+      input << STDIN.read_nonblock(3) rescue ""
+      input << STDIN.read_nonblock(2) rescue ""
+    end
+
+    input
+  end
+
+  def clear_screen
+    STDERR.print("\e[2J\e[H")
+  end
+
+  def hide_cursor
+    STDERR.print(Tui::ANSI::HIDE)
+  end
+
+  def show_cursor
+    STDERR.print(Tui::ANSI::SHOW)
+  end
+
+  def render(tries)
+    screen = Tui::Screen.new(io: STDERR)
+    width = screen.width
+    height = screen.height
+
+    screen.header.add_line { |line| line.write << emoji("🏠") << Tui::Text.accent(" Try Directory Selection") }
+    screen.header.add_line { |line| line.write.write_dim(fill("─")) }
+    screen.header.add_line do |line|
+      prefix = "Search: "
+      line.write.write_dim(prefix)
+      line.write << screen.input("", value: @input_buffer, cursor: @input_cursor_pos).to_s
+      line.mark_has_input(Tui::Metrics.visible_width(prefix))
+    end
+    screen.header.add_line { |line| line.write.write_dim(fill("─")) }
+
+    # Add footer first to get accurate line count
+    screen.footer.add_line { |line| line.write.write_dim(fill("─")) }
+    if @delete_status
+      screen.footer.add_line { |line| line.write.write_bold(@delete_status) }
+      @delete_status = nil
+    elsif @delete_mode
+      screen.footer.add_line(background: Tui::Palette::DANGER_BG) do |line|
+        line.write.write_bold(" DELETE MODE ")
+        line.write << " #{@marked_for_deletion.length} marked  |  Ctrl-D: Toggle  Enter: Confirm  Esc: Cancel"
+      end
+    else
+      screen.footer.add_line do |line|
+        line.center.write_dim("↑/↓: Navigate  Enter: Select  ^R: Rename  ^D: Delete  Esc: Cancel")
+      end
+    end
+
+    # Calculate max visible from actual header/footer counts
+    header_lines = screen.header.lines.length
+    footer_lines = screen.footer.lines.length
+    max_visible = [height - header_lines - footer_lines, 3].max
+    show_create_new = !@input_buffer.empty?
+    total_items = tries.length + (show_create_new ? 1 : 0)
+
+    if @cursor_pos < @scroll_offset
+      @scroll_offset = @cursor_pos
+    elsif @cursor_pos >= @scroll_offset + max_visible
+      @scroll_offset = @cursor_pos - max_visible + 1
+    end
+
+    visible_end = [@scroll_offset + max_visible, total_items].min
+
+    (@scroll_offset...visible_end).each do |idx|
+      if idx == tries.length && tries.any? && idx >= @scroll_offset
+        screen.body.add_line
+      end
+
+      if idx < tries.length
+        render_entry_line(screen, tries[idx], idx == @cursor_pos, width)
+      else
+        render_create_line(screen, idx == @cursor_pos, width)
+      end
+    end
+
+    screen.flush
+  end
+
+  def render_entry_line(screen, entry, is_selected, width)
+    is_marked = @marked_for_deletion.include?(entry[:path])
+    # Marked items always show red; selection shows via arrow only
+    background = if is_marked
+      Tui::Palette::DANGER_BG
+    elsif is_selected
+      Tui::Palette::SELECTED_BG
+    end
+
+    line = screen.body.add_line(background: background)
+    line.write << (is_selected ? Tui::Text.highlight("→ ") : "  ")
+    line.write << (is_marked ? emoji("🗑️") : emoji("📁")) << " "
+
+    plain_name, rendered_name = formatted_entry_name(entry)
+    prefix_width = 5
+    meta_text = "#{format_relative_time(entry[:mtime])}, #{format('%.1f', entry[:score])}"
+
+    # Only truncate name if it exceeds total line width (not to make room for metadata)
+    max_name_width = width - prefix_width - 1
+    if plain_name.length > max_name_width && max_name_width > 2
+      display_rendered = truncate_with_ansi(rendered_name, max_name_width - 1) + "…"
+    else
+      display_rendered = rendered_name
+    end
+
+    line.write << display_rendered
+
+    # Right content is lower layer - will be overwritten by left if they overlap
+    line.right.write_dim(meta_text)
+  end
+
+  def render_create_line(screen, is_selected, width)
+    background = is_selected ? Tui::Palette::SELECTED_BG : nil
+    line = screen.body.add_line(background: background)
+    line.write << (is_selected ? Tui::Text.highlight("→ ") : "  ")
+    date_prefix = Time.now.strftime("%Y-%m-%d")
+    label = if @input_buffer.empty?
+      "📂 Create new: #{date_prefix}-"
+    else
+      "📂 Create new: #{date_prefix}-#{@input_buffer}"
+    end
+    line.write << label
+  end
+
+  def formatted_entry_name(entry)
+    basename = entry[:basename]
+    positions = entry[:highlight_positions] || []
+
+    if basename =~ /^(\d{4}-\d{2}-\d{2})-(.+)$/
+      date_part = $1
+      name_part = $2
+      date_len = date_part.length + 1  # +1 for the hyphen
+
+      rendered = Tui::Text.dim(date_part)
+      # Highlight hyphen if it's in positions
+      rendered += positions.include?(10) ? Tui::Text.highlight('-') : Tui::Text.dim('-')
+      rendered += highlight_with_positions(name_part, positions, date_len)
+      ["#{date_part}-#{name_part}", rendered]
+    else
+      [basename, highlight_with_positions(basename, positions, 0)]
+    end
+  end
+
+  def highlight_with_positions(text, positions, offset)
+    result = ""
+    text.chars.each_with_index do |char, i|
+      if positions.include?(i + offset)
+        result += Tui::Text.highlight(char)
+      else
+        result += char
+      end
+    end
+    result
+  end
+
+  def format_relative_time(time)
+    return "?" unless time
+
+    seconds = Time.now - time
+    minutes = seconds / 60
+    hours = minutes / 60
+    days = hours / 24
+
+    if seconds < 60
+      "just now"
+    elsif minutes < 60
+      "#{minutes.to_i}m ago"
+    elsif hours < 24
+      "#{hours.to_i}h ago"
+    elsif days < 7
+      "#{days.to_i}d ago"
+    else
+      "#{(days/7).to_i}w ago"
+    end
+  end
+
+  def truncate_with_ansi(text, max_length)
+    # Simple truncation that preserves ANSI codes
+    visible_count = 0
+    result = ""
+    in_ansi = false
+
+    text.chars.each do |char|
+      if char == "\e"
+        in_ansi = true
+        result += char
+      elsif in_ansi
+        result += char
+        in_ansi = false if char == "m"
+      else
+        break if visible_count >= max_length
+        result += char
+        visible_count += 1
+      end
+    end
+
+    result
+  end
+
+  # Rename dialog - dedicated screen similar to delete
+  def run_rename_dialog(entry)
+    @delete_mode = false
+    @marked_for_deletion.clear
+
+    current_name = entry[:basename]
+    rename_buffer = current_name.dup
+    rename_cursor = rename_buffer.length
+    rename_error = nil
+
+    loop do
+      render_rename_dialog(current_name, rename_buffer, rename_cursor, rename_error)
+
+      ch = read_key
+      case ch
+      when "\r"  # Enter - confirm
+        result = finalize_rename(entry, rename_buffer)
+        if result == true
+          break
+        else
+          rename_error = result  # Error message string
+        end
+      when "\e", "\x03"  # ESC or Ctrl-C - cancel
+        break
+      when "\x7F", "\b"  # Backspace
+        if rename_cursor > 0
+          rename_buffer = rename_buffer[0...(rename_cursor - 1)] + rename_buffer[rename_cursor..].to_s
+          rename_cursor -= 1
+        end
+        rename_error = nil
+      when "\x01"  # Ctrl-A - start of line
+        rename_cursor = 0
+      when "\x05"  # Ctrl-E - end of line
+        rename_cursor = rename_buffer.length
+      when "\x02"  # Ctrl-B - back one char
+        rename_cursor = [rename_cursor - 1, 0].max
+      when "\x06"  # Ctrl-F - forward one char
+        rename_cursor = [rename_cursor + 1, rename_buffer.length].min
+      when "\x0B"  # Ctrl-K - kill to end
+        rename_buffer = rename_buffer[0...rename_cursor]
+        rename_error = nil
+      when "\x17"  # Ctrl-W - delete word backward
+        if rename_cursor > 0
+          pos = rename_cursor - 1
+          pos -= 1 while pos > 0 && rename_buffer[pos] !~ /[a-zA-Z0-9]/
+          pos -= 1 while pos > 0 && rename_buffer[pos - 1] =~ /[a-zA-Z0-9]/
+          rename_buffer = rename_buffer[0...pos] + rename_buffer[rename_cursor..].to_s
+          rename_cursor = pos
+        end
+        rename_error = nil
+      when String
+        if ch.length == 1 && ch =~ /[a-zA-Z0-9\-_\.\s\/]/
+          rename_buffer = rename_buffer[0...rename_cursor] + ch + rename_buffer[rename_cursor..].to_s
+          rename_cursor += 1
+          rename_error = nil
+        end
+      end
+    end
+
+    @needs_redraw = true
+  end
+
+  def render_rename_dialog(current_name, rename_buffer, rename_cursor, rename_error)
+    screen = Tui::Screen.new(io: STDERR)
+
+    screen.header.add_line do |line|
+      line.center << emoji("✏️") << Tui::Text.accent("  Rename directory")
+    end
+    screen.header.add_line { |line| line.write.write_dim(fill("─")) }
+
+    screen.body.add_line do |line|
+      line.write << emoji("📁") << " #{current_name}"
+    end
+
+    # Add empty lines, then centered input prompt
+    2.times { screen.body.add_line }
+    screen.body.add_line do |line|
+      prefix = "New name: "
+      line.center.write_dim(prefix)
+      line.center << screen.input("", value: rename_buffer, cursor: rename_cursor).to_s
+      # Input displays buffer + trailing space when cursor at end
+      # Use (width - 1) to match Line.render's max_content calculation
+      input_width = [rename_buffer.length, rename_cursor + 1].max
+      prefix_width = Tui::Metrics.visible_width(prefix)
+      max_content = screen.width - 1
+      center_start = (max_content - prefix_width - input_width) / 2
+      line.mark_has_input(center_start + prefix_width)
+    end
+
+    if rename_error
+      screen.body.add_line
+      screen.body.add_line { |line| line.center.write_bold(rename_error) }
+    end
+
+    screen.footer.add_line { |line| line.write.write_dim(fill("─")) }
+    screen.footer.add_line { |line| line.center.write_dim("Enter: Confirm  Esc: Cancel") }
+
+    screen.flush
+  end
+
+  def finalize_rename(entry, rename_buffer)
+    new_name = rename_buffer.strip.gsub(/\s+/, '-')
+    old_name = entry[:basename]
+
+    return "Name cannot be empty" if new_name.empty?
+    return "Name cannot contain /" if new_name.include?('/')
+    return true if new_name == old_name  # No change, just exit
+    return "Directory exists: #{new_name}" if Dir.exist?(File.join(@base_path, new_name))
+
+    @selected = { type: :rename, old: old_name, new: new_name, base_path: @base_path }
+    true
+  end
+
+  def handle_selection(try_dir)
+    # Select existing try directory
+    @selected = { type: :cd, path: try_dir[:path] }
+  end
+
+  def handle_create_new
+    # Create new try directory
+    date_prefix = Time.now.strftime("%Y-%m-%d")
+
+    # If user already typed a name, use it directly
+    if !@input_buffer.empty?
+      final_name = "#{date_prefix}-#{@input_buffer}".gsub(/\s+/, '-')
+      full_path = File.join(@base_path, final_name)
+      @selected = { type: :mkdir, path: full_path }
+    else
+      # No name typed, prompt for one
+      entry = ""
+      begin
+        clear_screen unless @test_no_cls
+        show_cursor
+        STDERR.puts "Enter new try name"
+        STDERR.puts
+        STDERR.print("> #{date_prefix}-")
+        STDERR.flush
+
+        STDERR.cooked do
+          STDIN.iflush
+          entry = STDIN.gets&.chomp.to_s
+        end
+      ensure
+        hide_cursor unless @test_no_cls
+      end
+
+      return if entry.nil? || entry.empty?
+
+      final_name = "#{date_prefix}-#{entry}".gsub(/\s+/, '-')
+      full_path = File.join(@base_path, final_name)
+
+      @selected = { type: :mkdir, path: full_path }
+      end
+  end
+
+  def confirm_batch_delete(tries)
+    # Find marked items with their info
+    marked_items = tries.select { |t| @marked_for_deletion.include?(t[:path]) }
+    return if marked_items.empty?
+
+    confirmation_buffer = ""
+    confirmation_cursor = 0
+
+    # Handle test mode
+    if @test_keys && !@test_keys.empty?
+      while @test_keys && !@test_keys.empty?
+        ch = @test_keys.shift
+        break if ch == "\r" || ch == "\n"
+        confirmation_buffer << ch
+        confirmation_cursor = confirmation_buffer.length
+      end
+      process_delete_confirmation(marked_items, confirmation_buffer)
+      return
+    elsif @test_confirm || !STDERR.tty?
+      confirmation_buffer = (@test_confirm || STDIN.gets)&.chomp.to_s
+      process_delete_confirmation(marked_items, confirmation_buffer)
+      return
+    end
+
+    # Interactive delete confirmation dialog
+    # Clear screen once before dialog to ensure clean slate
+    clear_screen unless @test_no_cls
+    loop do
+      render_delete_dialog(marked_items, confirmation_buffer, confirmation_cursor)
+
+      ch = read_key
+      case ch
+      when "\r"  # Enter - confirm
+        process_delete_confirmation(marked_items, confirmation_buffer)
+        break
+      when "\e"  # Escape - cancel
+        @delete_status = "Delete cancelled"
+        @marked_for_deletion.clear
+        @delete_mode = false
+        break
+      when "\x7F", "\b"  # Backspace
+        if confirmation_cursor > 0
+          confirmation_buffer = confirmation_buffer[0...confirmation_cursor-1] + confirmation_buffer[confirmation_cursor..]
+          confirmation_cursor -= 1
+        end
+      when "\x03"  # Ctrl-C
+        @delete_status = "Delete cancelled"
+        @marked_for_deletion.clear
+        @delete_mode = false
+        break
+      when String
+        if ch.length == 1 && ch.ord >= 32
+          confirmation_buffer = confirmation_buffer[0...confirmation_cursor] + ch + confirmation_buffer[confirmation_cursor..]
+          confirmation_cursor += 1
+        end
+      end
+    end
+
+    @needs_redraw = true
+  end
+
+  def render_delete_dialog(marked_items, confirmation_buffer, confirmation_cursor)
+    screen = Tui::Screen.new(io: STDERR)
+
+    count = marked_items.length
+    screen.header.add_line do |line|
+      line.center << emoji("🗑️") << Tui::Text.accent("  Delete #{count} #{count == 1 ? 'directory' : 'directories'}?")
+    end
+    screen.header.add_line { |line| line.write.write_dim(fill("─")) }
+
+    marked_items.each do |item|
+      screen.body.add_line(background: Tui::Palette::DANGER_BG) do |line|
+        line.write << emoji("🗑️") << " #{item[:basename]}"
+      end
+    end
+
+    # Add empty lines, then centered confirmation prompt
+    2.times { screen.body.add_line }
+    screen.body.add_line do |line|
+      prefix = "Type YES to confirm: "
+      line.center.write_dim(prefix)
+      line.center << screen.input("", value: confirmation_buffer, cursor: confirmation_cursor).to_s
+      # Input displays buffer + trailing space when cursor at end
+      # Use (width - 1) to match Line.render's max_content calculation
+      input_width = [confirmation_buffer.length, confirmation_cursor + 1].max
+      prefix_width = Tui::Metrics.visible_width(prefix)
+      max_content = screen.width - 1
+      center_start = (max_content - prefix_width - input_width) / 2
+      line.mark_has_input(center_start + prefix_width)
+    end
+
+    screen.footer.add_line { |line| line.write.write_dim(fill("─")) }
+    screen.footer.add_line { |line| line.center.write_dim("Enter: Confirm  Esc: Cancel") }
+
+    screen.flush
+  end
+
+  def process_delete_confirmation(marked_items, confirmation)
+    if confirmation == "YES"
+      begin
+        base_real = File.realpath(@base_path)
+
+        # Validate all paths first
+        validated_paths = []
+        marked_items.each do |item|
+          target_real = File.realpath(item[:path])
+          unless target_real.start_with?(base_real + "/")
+            raise "Safety check failed: #{target_real} is not inside #{base_real}"
+          end
+          validated_paths << { path: target_real, basename: item[:basename] }
+        end
+
+        # Return delete action with all paths
+        @selected = { type: :delete, paths: validated_paths, base_path: base_real }
+        names = validated_paths.map { |p| p[:basename] }.join(", ")
+        @delete_status = "Deleted: #{names}"
+        @all_tries = nil  # Clear cache
+        @fuzzy = nil
+        @marked_for_deletion.clear
+        @delete_mode = false
+      rescue => e
+        @delete_status = "Error: #{e.message}"
+      end
+    else
+      @delete_status = "Delete cancelled"
+      @marked_for_deletion.clear
+      @delete_mode = false
+    end
+  end
+end
+
+# Main execution with OptionParser subcommands
+if __FILE__ == $0
+
+  VERSION = "1.7.1"
+
+  def print_global_help
+    text = <<~HELP
+      try v#{VERSION} - ephemeral workspace manager
+
+      To use try, add to your shell config:
+
+        # bash/zsh (~/.bashrc or ~/.zshrc)
+        eval "$(try init ~/src/tries)"
+
+        # fish (~/.config/fish/config.fish)
+        eval (try init ~/src/tries | string collect)
+
+      Usage:
+        try [query]           Interactive directory selector
+        try clone <url>       Clone repo into dated directory
+        try worktree <name>   Create worktree from current git repo
+        try --help            Show this help
+
+      Commands:
+        init [path]           Output shell function definition
+        clone <url> [name]    Clone git repo into date-prefixed directory
+        worktree <name>       Create worktree in dated directory
+
+      Examples:
+        try                   Open interactive selector
+        try project           Selector with initial filter
+        try clone https://github.com/user/repo
+        try worktree feature-branch
+
+      Manual mode (without alias):
+        try exec [query]      Output shell script to eval
+
+      Defaults:
+        Default path: ~/src/tries
+        Current: #{TrySelector::TRY_PATH}
+    HELP
+    STDOUT.print(text)
+  end
+
+  # Process color-related flags early
+  disable_colors = ARGV.delete('--no-colors')
+  disable_colors ||= ARGV.delete('--no-expand-tokens')
+
+  Tui.disable_colors! if disable_colors
+  Tui.disable_colors! if ENV['NO_COLOR'] && !ENV['NO_COLOR'].empty?
+
+  # Global help: show for --help/-h anywhere
+  if ARGV.include?("--help") || ARGV.include?("-h")
+    print_global_help
+    exit 0
+  end
+
+  # Version flag
+  if ARGV.include?("--version") || ARGV.include?("-v")
+    puts "try #{VERSION}"
+    exit 0
+  end
+
+  # Helper to extract a "--name VALUE" or "--name=VALUE" option from args (last one wins)
+  def extract_option_with_value!(args, opt_name)
+    i = args.rindex { |a| a == opt_name || a.start_with?("#{opt_name}=") }
+    return nil unless i
+    arg = args.delete_at(i)
+    if arg.include?('=')
+      arg.split('=', 2)[1]
+    else
+      args.delete_at(i)
+    end
+  end
+
+  def parse_git_uri(uri)
+    # Remove .git suffix if present
+    uri = uri.sub(/\.git$/, '')
+
+    # Handle different git URI formats
+    if uri.match(%r{^https?://github\.com/([^/]+)/([^/]+)})
+      # https://github.com/user/repo
+      user, repo = $1, $2
+      return { user: user, repo: repo, host: 'github.com' }
+    elsif uri.match(%r{^git@github\.com:([^/]+)/([^/]+)})
+      # git@github.com:user/repo
+      user, repo = $1, $2
+      return { user: user, repo: repo, host: 'github.com' }
+    elsif uri.match(%r{^https?://([^/]+)/([^/]+)/([^/]+)})
+      # https://gitlab.com/user/repo or other git hosts
+      host, user, repo = $1, $2, $3
+      return { user: user, repo: repo, host: host }
+    elsif uri.match(%r{^git@([^:]+):([^/]+)/([^/]+)})
+      # git@host:user/repo
+      host, user, repo = $1, $2, $3
+      return { user: user, repo: repo, host: host }
+    else
+      return nil
+    end
+  end
+
+  def generate_clone_directory_name(git_uri, custom_name = nil)
+    return custom_name if custom_name && !custom_name.empty?
+
+    parsed = parse_git_uri(git_uri)
+    return nil unless parsed
+
+    date_prefix = Time.now.strftime("%Y-%m-%d")
+    "#{date_prefix}-#{parsed[:user]}-#{parsed[:repo]}"
+  end
+
+  def is_git_uri?(arg)
+    return false unless arg
+    arg.match?(%r{^(https?://|git@)}) || arg.include?('github.com') || arg.include?('gitlab.com') || arg.end_with?('.git')
+  end
+
+  # Extract all options BEFORE getting command (they can appear anywhere)
+  tries_path = extract_option_with_value!(ARGV, '--path') || TrySelector::TRY_PATH
+  tries_path = File.expand_path(tries_path)
+
+  # Test-only flags (undocumented; aid acceptance tests)
+  # Must be extracted before command shift since they can come before command
+  and_type = extract_option_with_value!(ARGV, '--and-type')
+  and_exit = !!ARGV.delete('--and-exit')
+  and_keys_raw = extract_option_with_value!(ARGV, '--and-keys')
+  and_confirm = extract_option_with_value!(ARGV, '--and-confirm')
+  # Note: --no-expand-tokens and --no-colors are processed early (before --help check)
+
+  command = ARGV.shift
+
+  def parse_test_keys(spec)
+    return nil unless spec && !spec.empty?
+
+    # Detect mode: if contains comma OR is purely uppercase letters/hyphens, use token mode
+    # Otherwise use raw character mode (for spec tests that pass literal key sequences)
+    use_token_mode = spec.include?(',') || spec.match?(/^[A-Z\-]+$/)
+
+    if use_token_mode
+      tokens = spec.split(/,\s*/)
+      keys = []
+      tokens.each do |tok|
+        up = tok.upcase
+        case up
+        when 'UP' then keys << "\e[A"
+        when 'DOWN' then keys << "\e[B"
+        when 'LEFT' then keys << "\e[D"
+        when 'RIGHT' then keys << "\e[C"
+        when 'ENTER' then keys << "\r"
+        when 'ESC' then keys << "\e"
+        when 'BACKSPACE' then keys << "\x7F"
+        when 'CTRL-A', 'CTRLA' then keys << "\x01"
+        when 'CTRL-B', 'CTRLB' then keys << "\x02"
+        when 'CTRL-D', 'CTRLD' then keys << "\x04"
+        when 'CTRL-E', 'CTRLE' then keys << "\x05"
+        when 'CTRL-F', 'CTRLF' then keys << "\x06"
+        when 'CTRL-H', 'CTRLH' then keys << "\x08"
+        when 'CTRL-K', 'CTRLK' then keys << "\x0B"
+        when 'CTRL-N', 'CTRLN' then keys << "\x0E"
+        when 'CTRL-P', 'CTRLP' then keys << "\x10"
+        when 'CTRL-R', 'CTRLR' then keys << "\x12"
+        when 'CTRL-T', 'CTRLT' then keys << "\x14"
+        when 'CTRL-W', 'CTRLW' then keys << "\x17"
+        when /^TYPE=(.*)$/
+          $1.each_char { |ch| keys << ch }
+        else
+          keys << tok if tok.length == 1
+        end
+      end
+      keys
+    else
+      # Raw character mode: each character (including escape sequences) is a key
+      keys = []
+      i = 0
+      while i < spec.length
+        if spec[i] == "\e" && i + 2 < spec.length && spec[i + 1] == '['
+          # Escape sequence like \e[A for arrow keys
+          keys << spec[i, 3]
+          i += 3
+        else
+          keys << spec[i]
+          i += 1
+        end
+      end
+      keys
+    end
+  end
+  and_keys = parse_test_keys(and_keys_raw)
+
+  def cmd_clone!(args, tries_path)
+    git_uri = args.shift
+    custom_name = args.shift
+
+    unless git_uri
+      warn "Error: git URI required for clone command"
+      warn "Usage: try clone <git-uri> [name]"
+      exit 1
+    end
+
+    dir_name = generate_clone_directory_name(git_uri, custom_name)
+    unless dir_name
+      warn "Error: Unable to parse git URI: #{git_uri}"
+      exit 1
+    end
+
+    script_clone(File.join(tries_path, dir_name), git_uri)
+  end
+
+  def cmd_init!(args, tries_path)
+    script_path = File.expand_path($0)
+
+    if args[0] && args[0].start_with?('/')
+      tries_path = File.expand_path(args.shift)
+    end
+
+    path_arg = tries_path ? " --path '#{tries_path}'" : ""
+    bash_or_zsh_script = <<~SHELL
+      try() {
+        local out
+        out=$(/usr/bin/env ruby '#{script_path}' exec#{path_arg} "$@" 2>/dev/tty)
+        if [ $? -eq 0 ]; then
+          eval "$out"
+        else
+          echo "$out"
+        fi
+      }
+    SHELL
+
+    fish_script = <<~SHELL
+      function try
+        set -l out (/usr/bin/env ruby '#{script_path}' exec#{path_arg} $argv 2>/dev/tty | string collect)
+        if test $status -eq 0
+          eval $out
+        else
+          echo $out
+        end
+      end
+    SHELL
+
+    puts fish? ? fish_script : bash_or_zsh_script
+    exit 0
+  end
+
+  def cmd_cd!(args, tries_path, and_type, and_exit, and_keys, and_confirm)
+    if args.first == "clone"
+      return cmd_clone!(args[1..-1] || [], tries_path)
+    end
+
+    # Support: try . [name] and try ./path [name]
+    if args.first && args.first.start_with?('.')
+      path_arg = args.shift
+      custom = args.join(' ')
+      repo_dir = File.expand_path(path_arg)
+      # Bare "try ." requires a name argument (too easy to invoke accidentally)
+      if path_arg == '.' && (custom.nil? || custom.strip.empty?)
+        STDERR.puts "Error: 'try .' requires a name argument"
+        STDERR.puts "Usage: try . <name>"
+        exit 1
+      end
+      base = if custom && !custom.strip.empty?
+        custom.gsub(/\s+/, '-')
+      else
+        File.basename(repo_dir)
+      end
+      date_prefix = Time.now.strftime("%Y-%m-%d")
+      base = resolve_unique_name_with_versioning(tries_path, date_prefix, base)
+      full_path = File.join(tries_path, "#{date_prefix}-#{base}")
+      # Use worktree if .git exists (file in worktrees, directory in regular repos)
+      if File.exist?(File.join(repo_dir, '.git'))
+        return script_worktree(full_path, repo_dir)
+      else
+        return script_mkdir_cd(full_path)
+      end
+    end
+
+    search_term = args.join(' ')
+
+    # Git URL shorthand → clone workflow
+    if is_git_uri?(search_term.split.first)
+      git_uri, custom_name = search_term.split(/\s+/, 2)
+      dir_name = generate_clone_directory_name(git_uri, custom_name)
+      unless dir_name
+        warn "Error: Unable to parse git URI: #{git_uri}"
+        exit 1
+      end
+      full_path = File.join(tries_path, dir_name)
+      return script_clone(full_path, git_uri)
+    end
+
+    # Regular interactive selector
+    selector = TrySelector.new(
+      search_term,
+      base_path: tries_path,
+      initial_input: and_type,
+      test_render_once: and_exit,
+      test_no_cls: (and_exit || (and_keys && !and_keys.empty?)),
+      test_keys: and_keys,
+      test_confirm: and_confirm
+    )
+    result = selector.run
+    return nil unless result
+
+    case result[:type]
+    when :delete
+      script_delete(result[:paths], result[:base_path])
+    when :mkdir
+      script_mkdir_cd(result[:path])
+    when :rename
+      script_rename(result[:base_path], result[:old], result[:new])
+    else
+      script_cd(result[:path])
+    end
+  end
+
+  # --- Shell script helpers ---
+  SCRIPT_WARNING = "# if you can read this, you didn't launch try from an alias. run try --help."
+
+  def q(str)
+    "'" + str.gsub("'", %q('"'"')) + "'"
+  end
+
+  def emit_script(cmds)
+    puts SCRIPT_WARNING
+    cmds.each_with_index do |cmd, i|
+      if i == 0
+        print cmd
+      else
+        print "  #{cmd}"
+      end
+      if i < cmds.length - 1
+        puts " && \\"
+      else
+        puts
+      end
+    end
+  end
+
+  def script_cd(path)
+    ["touch #{q(path)}", "echo #{q(path)}", "cd #{q(path)}"]
+  end
+
+  def script_mkdir_cd(path)
+    ["mkdir -p #{q(path)}"] + script_cd(path)
+  end
+
+  def script_clone(path, uri)
+    ["mkdir -p #{q(path)}", "echo #{q("Using git clone to create this trial from #{uri}.")}", "git clone '#{uri}' #{q(path)}"] + script_cd(path)
+  end
+
+  def script_worktree(path, repo = nil)
+    r = repo ? q(repo) : nil
+    worktree_cmd = if r
+      "/usr/bin/env sh -c 'if git -C #{r} rev-parse --is-inside-work-tree >/dev/null 2>&1; then repo=$(git -C #{r} rev-parse --show-toplevel); git -C \"$repo\" worktree add --detach #{q(path)} >/dev/null 2>&1 || true; fi; exit 0'"
+    else
+      "/usr/bin/env sh -c 'if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then repo=$(git rev-parse --show-toplevel); git -C \"$repo\" worktree add --detach #{q(path)} >/dev/null 2>&1 || true; fi; exit 0'"
+    end
+    src = repo || Dir.pwd
+    ["mkdir -p #{q(path)}", "echo #{q("Using git worktree to create this trial from #{src}.")}", worktree_cmd] + script_cd(path)
+  end
+
+  def script_delete(paths, base_path)
+    cmds = ["cd #{q(base_path)}"]
+    paths.each { |item| cmds << "test -d #{q(item[:basename])} && rm -rf #{q(item[:basename])}" }
+    cmds << "( cd #{q(Dir.pwd)} 2>/dev/null || cd \"$HOME\" )"
+    cmds
+  end
+
+  def script_rename(base_path, old_name, new_name)
+    new_path = File.join(base_path, new_name)
+    [
+      "cd #{q(base_path)}",
+      "mv #{q(old_name)} #{q(new_name)}",
+      "echo #{q(new_path)}",
+      "cd #{q(new_path)}"
+    ]
+  end
+
+  # Return a unique directory name under tries_path by appending -2, -3, ... if needed
+  def unique_dir_name(tries_path, dir_name)
+    candidate = dir_name
+    i = 2
+    while Dir.exist?(File.join(tries_path, candidate))
+      candidate = "#{dir_name}-#{i}"
+      i += 1
+    end
+    candidate
+  end
+
+  # If the given base ends with digits and today's dir already exists,
+  # bump the trailing number to the next available one for today.
+  # Otherwise, fall back to unique_dir_name with -2, -3 suffixes.
+  def resolve_unique_name_with_versioning(tries_path, date_prefix, base)
+    initial = "#{date_prefix}-#{base}"
+    return base unless Dir.exist?(File.join(tries_path, initial))
+
+    m = base.match(/^(.*?)(\d+)$/)
+    if m
+      stem, n = m[1], m[2].to_i
+      candidate_num = n + 1
+      loop do
+        candidate_base = "#{stem}#{candidate_num}"
+        candidate_full = File.join(tries_path, "#{date_prefix}-#{candidate_base}")
+        return candidate_base unless Dir.exist?(candidate_full)
+        candidate_num += 1
+      end
+    else
+      # No numeric suffix; use -2 style uniqueness on full name
+      return unique_dir_name(tries_path, "#{date_prefix}-#{base}").sub(/^#{Regexp.escape(date_prefix)}-/, '')
+    end
+  end
+
+  # shell detection for init wrapper
+  # Check $SHELL first (user's configured shell), then parent process as fallback
+  def fish?
+    shell = ENV["SHELL"]
+    shell = `ps c -p #{Process.ppid} -o 'ucomm='`.strip rescue nil if shell.to_s.empty?
+
+    shell&.include?('fish')
+  end
+
+
+  # Helper to generate worktree path from repo
+  def worktree_path(tries_path, repo_dir, custom_name)
+    base = if custom_name && !custom_name.strip.empty?
+      custom_name.gsub(/\s+/, '-')
+    else
+      begin; File.basename(File.realpath(repo_dir)); rescue; File.basename(repo_dir); end
+    end
+    date_prefix = Time.now.strftime("%Y-%m-%d")
+    base = resolve_unique_name_with_versioning(tries_path, date_prefix, base)
+    File.join(tries_path, "#{date_prefix}-#{base}")
+  end
+
+  case command
+  when nil
+    print_global_help
+    exit 2
+  when 'clone'
+    emit_script(cmd_clone!(ARGV, tries_path))
+    exit 0
+  when 'init'
+    cmd_init!(ARGV, tries_path)
+    exit 0
+  when 'exec'
+    sub = ARGV.first
+    case sub
+    when 'clone'
+      ARGV.shift
+      emit_script(cmd_clone!(ARGV, tries_path))
+    when 'worktree'
+      ARGV.shift
+      repo = ARGV.shift
+      repo_dir = repo && repo != 'dir' ? File.expand_path(repo) : Dir.pwd
+      full_path = worktree_path(tries_path, repo_dir, ARGV.join(' '))
+      emit_script(script_worktree(full_path, repo_dir == Dir.pwd ? nil : repo_dir))
+    when 'cd'
+      ARGV.shift
+      script = cmd_cd!(ARGV, tries_path, and_type, and_exit, and_keys, and_confirm)
+      if script
+        emit_script(script)
+        exit 0
+      else
+        puts "Cancelled."
+        exit 1
+      end
+    else
+      script = cmd_cd!(ARGV, tries_path, and_type, and_exit, and_keys, and_confirm)
+      if script
+        emit_script(script)
+        exit 0
+      else
+        puts "Cancelled."
+        exit 1
+      end
+    end
+  when 'worktree'
+    repo = ARGV.shift
+    repo_dir = repo && repo != 'dir' ? File.expand_path(repo) : Dir.pwd
+    full_path = worktree_path(tries_path, repo_dir, ARGV.join(' '))
+    # Explicit worktree command always emits worktree script
+    emit_script(script_worktree(full_path, repo_dir == Dir.pwd ? nil : repo_dir))
+    exit 0
+  else
+    # Default: try [query] - same as try exec [query]
+    script = cmd_cd!(ARGV.unshift(command), tries_path, and_type, and_exit, and_keys, and_confirm)
+    if script
+      emit_script(script)
+      exit 0
+    else
+      puts "Cancelled."
+      exit 1
+    end
+  end
+
+end