beniya 0.6.1 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eabacf1e9c20898106af324c8275d857b209150badec6518d211a1820a78778f
-  data.tar.gz: 4e43ee255191fdad616db68a320d77f326e7fb925932145cdf6e528a4f6f67ef
+  metadata.gz: c82332a61b93f69a73371f2f9d4aa4488d04fc45b12f5db958bd0597476a8550
+  data.tar.gz: 5f689d6a5fb75451d3f8b75ff9f09343f342d80e451b19de39e0a024fdf688dc
 SHA512:
-  metadata.gz: 19f7fba9a329ca1dae8b3fa1d63898af7e0f16030bbf60cb8e8b10d5af02d4e2bbba783fef30df30e2c212fef06bb07628b9122139d0c50a093752f4a2bdb0a0
-  data.tar.gz: d3a21a8322852750a2410145ffbd63d4c0ed72c7ae5485b6763f68d192872f05a4b7ddea62900ca910c21e04252347bcbcd679b2c1b5fbbe7721734fea8db2d8
+  metadata.gz: f8e95d8c526f42619d798107a447b103a592005699a06392c61bf05919df0fe090c2066dc427aa6e047d35ec8d19285f11cd6696bf9ff4aa96d810b9bb465a82
+  data.tar.gz: 6baebd7f5d4c288589d0f1a88b7ed871f0d344529787cc42356ed741c51ca47aa8758c7f25dd4dc9e31ac3804180ea1e23ae14e80642ffb7ee972e7622aed32e

data/lib/beniya/bookmark_manager.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative 'bookmark'
+require_relative 'config_loader'
+
+module Beniya
+  # Manages bookmark operations with interactive UI
+  class BookmarkManager
+    def initialize(bookmark = nil, dialog_renderer = nil)
+      @bookmark = bookmark || Bookmark.new
+      @dialog_renderer = dialog_renderer
+    end
+
+    # Show bookmark menu and handle user selection
+    # @param current_path [String] Current directory path
+    # @return [Symbol, nil] Action to perform (:navigate, :add, :list, :remove, :cancel)
+    def show_menu(current_path)
+      return :cancel unless @dialog_renderer
+
+      title = 'Bookmark Menu'
+      content_lines = [
+        '',
+        '[A]dd current directory to bookmarks',
+        '[L]ist bookmarks',
+        '[R]emove bookmark',
+        '',
+        'Press 1-9 to go to bookmark directly',
+        '',
+        'Press any other key to cancel'
+      ]
+
+      dialog_width = 45
+      dialog_height = 4 + content_lines.length
+      x, y = @dialog_renderer.calculate_center(dialog_width, dialog_height)
+
+      @dialog_renderer.draw_floating_window(x, y, dialog_width, dialog_height, title, content_lines, {
+                                               border_color: "\e[34m", # Blue
+                                               title_color: "\e[1;34m",   # Bold blue
+                                               content_color: "\e[37m"    # White
+                                             })
+
+      # Wait for key input
+      loop do
+        input = STDIN.getch.downcase
+
+        case input
+        when 'a'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :add, path: current_path }
+        when 'l'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :list }
+        when 'r'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :remove }
+        when '1', '2', '3', '4', '5', '6', '7', '8', '9'
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :navigate, number: input.to_i }
+        else
+          # Cancel
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return { action: :cancel }
+        end
+      end
+    end
+
+    # Add a bookmark interactively
+    # @param path [String] Path to bookmark
+    # @return [Boolean] Success status
+    def add_interactive(path)
+      print ConfigLoader.message('bookmark.input_name') || 'Enter bookmark name: '
+      name = STDIN.gets.chomp
+      return false if name.empty?
+
+      if @bookmark.add(path, name)
+        puts "\n#{ConfigLoader.message('bookmark.added') || 'Bookmark added'}: #{name}"
+        true
+      else
+        puts "\n#{ConfigLoader.message('bookmark.add_failed') || 'Failed to add bookmark'}"
+        false
+      end
+    end
+
+    # Remove a bookmark interactively
+    # @return [Boolean] Success status
+    def remove_interactive
+      bookmarks = @bookmark.list
+
+      if bookmarks.empty?
+        puts "\n#{ConfigLoader.message('bookmark.no_bookmarks') || 'No bookmarks found'}"
+        return false
+      end
+
+      puts "\nBookmarks:"
+      bookmarks.each_with_index do |bookmark, index|
+        puts "  #{index + 1}. #{bookmark[:name]} (#{bookmark[:path]})"
+      end
+
+      print ConfigLoader.message('bookmark.input_number') || 'Enter number to remove: '
+      input = STDIN.gets.chomp
+      number = input.to_i
+
+      if number > 0 && number <= bookmarks.length
+        bookmark_to_remove = bookmarks[number - 1]
+        if @bookmark.remove(bookmark_to_remove[:name])
+          puts "\n#{ConfigLoader.message('bookmark.removed') || 'Bookmark removed'}: #{bookmark_to_remove[:name]}"
+          true
+        else
+          puts "\n#{ConfigLoader.message('bookmark.remove_failed') || 'Failed to remove bookmark'}"
+          false
+        end
+      else
+        puts "\n#{ConfigLoader.message('bookmark.invalid_number') || 'Invalid number'}"
+        false
+      end
+    end
+
+    # List all bookmarks interactively
+    # @return [Boolean] Success status
+    def list_interactive
+      bookmarks = @bookmark.list
+
+      if bookmarks.empty?
+        puts "\n#{ConfigLoader.message('bookmark.no_bookmarks') || 'No bookmarks found'}"
+        return false
+      end
+
+      puts "\nBookmarks:"
+      bookmarks.each_with_index do |bookmark, index|
+        puts "  #{index + 1}. #{bookmark[:name]} (#{bookmark[:path]})"
+      end
+
+      true
+    end
+
+    # Get bookmark by number
+    # @param number [Integer] Bookmark number (1-9)
+    # @return [Hash, nil] Bookmark hash with :path and :name
+    def find_by_number(number)
+      @bookmark.find_by_number(number)
+    end
+
+    # Validate bookmark path exists
+    # @param bookmark [Hash] Bookmark hash
+    # @return [Boolean]
+    def path_exists?(bookmark)
+      return false unless bookmark
+
+      Dir.exist?(bookmark[:path])
+    end
+
+    # Get all bookmarks
+    # @return [Array<Hash>]
+    def list
+      @bookmark.list
+    end
+
+    # Add bookmark
+    # @param path [String] Path to bookmark
+    # @param name [String] Bookmark name
+    # @return [Boolean] Success status
+    def add(path, name)
+      @bookmark.add(path, name)
+    end
+
+    # Remove bookmark
+    # @param name [String] Bookmark name
+    # @return [Boolean] Success status
+    def remove(name)
+      @bookmark.remove(name)
+    end
+  end
+end

data/lib/beniya/dialog_renderer.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'text_utils'
+
+module Beniya
+  # Renders floating dialog windows in the terminal
+  class DialogRenderer
+    include TextUtils
+
+    # Draw a floating window with title, content, and customizable colors
+    # @param x [Integer] X position (column)
+    # @param y [Integer] Y position (row)
+    # @param width [Integer] Window width
+    # @param height [Integer] Window height
+    # @param title [String, nil] Window title (optional)
+    # @param content_lines [Array<String>] Content lines to display
+    # @param options [Hash] Customization options
+    # @option options [String] :border_color Border color ANSI code
+    # @option options [String] :title_color Title color ANSI code
+    # @option options [String] :content_color Content color ANSI code
+    def draw_floating_window(x, y, width, height, title, content_lines, options = {})
+      # Default options
+      border_color = options[:border_color] || "\e[37m"  # White
+      title_color = options[:title_color] || "\e[1;33m"  # Bold yellow
+      content_color = options[:content_color] || "\e[37m" # White
+      reset_color = "\e[0m"
+
+      # Draw top border
+      print "\e[#{y};#{x}H#{border_color}┌#{'─' * (width - 2)}┐#{reset_color}"
+
+      # Draw title line if title exists
+      if title
+        title_width = TextUtils.display_width(title)
+        title_padding = (width - 2 - title_width) / 2
+        padded_title = ' ' * title_padding + title
+        title_line = TextUtils.pad_string_to_width(padded_title, width - 2)
+        print "\e[#{y + 1};#{x}H#{border_color}│#{title_color}#{title_line}#{border_color}│#{reset_color}"
+
+        # Draw title separator
+        print "\e[#{y + 2};#{x}H#{border_color}├#{'─' * (width - 2)}┤#{reset_color}"
+        content_start_y = y + 3
+      else
+        content_start_y = y + 1
+      end
+
+      # Draw content lines
+      content_height = title ? height - 4 : height - 2
+      content_lines.each_with_index do |line, index|
+        break if index >= content_height
+
+        line_y = content_start_y + index
+        line_content = TextUtils.pad_string_to_width(line, width - 2)
+        print "\e[#{line_y};#{x}H#{border_color}│#{content_color}#{line_content}#{border_color}│#{reset_color}"
+      end
+
+      # Fill remaining lines with empty space
+      remaining_lines = content_height - content_lines.length
+      remaining_lines.times do |i|
+        line_y = content_start_y + content_lines.length + i
+        empty_line = ' ' * (width - 2)
+        print "\e[#{line_y};#{x}H#{border_color}│#{empty_line}│#{reset_color}"
+      end
+
+      # Draw bottom border
+      bottom_y = y + height - 1
+      print "\e[#{bottom_y};#{x}H#{border_color}└#{'─' * (width - 2)}┘#{reset_color}"
+    end
+
+    # Calculate center position for a window
+    # @param content_width [Integer] Window width
+    # @param content_height [Integer] Window height
+    # @return [Array<Integer>] [x, y] position
+    def calculate_center(content_width, content_height)
+      # Get terminal size
+      console = IO.console
+      if console
+        screen_width, screen_height = console.winsize.reverse
+      else
+        screen_width = 80
+        screen_height = 24
+      end
+
+      # Calculate center position
+      x = [(screen_width - content_width) / 2, 1].max
+      y = [(screen_height - content_height) / 2, 1].max
+
+      [x, y]
+    end
+
+    # Clear a rectangular area on the screen
+    # @param x [Integer] X position
+    # @param y [Integer] Y position
+    # @param width [Integer] Area width
+    # @param height [Integer] Area height
+    def clear_area(x, y, width, height)
+      height.times do |row|
+        print "\e[#{y + row};#{x}H#{' ' * width}"
+      end
+    end
+
+    # Calculate appropriate dimensions for content
+    # @param content_lines [Array<String>] Content lines
+    # @param options [Hash] Options
+    # @option options [String, nil] :title Window title
+    # @option options [Integer] :min_width Minimum width (default: 30)
+    # @option options [Integer] :max_width Maximum width (default: 80)
+    # @return [Array<Integer>] [width, height]
+    def calculate_dimensions(content_lines, options = {})
+      title = options[:title]
+      min_width = options[:min_width] || 30
+      max_width = options[:max_width] || 80
+
+      # Calculate required width based on content
+      max_content_width = content_lines.map { |line| TextUtils.display_width(line) }.max || 0
+      title_width = title ? TextUtils.display_width(title) : 0
+      required_width = [max_content_width, title_width].max + 4 # +4 for borders and padding
+
+      width = [[required_width, min_width].max, max_width].min
+
+      # Calculate height: borders + title (if exists) + separator + content
+      height = content_lines.length + 2 # +2 for top and bottom borders
+      height += 2 if title # +2 for title line and separator
+
+      [width, height]
+    end
+  end
+end

data/lib/beniya/file_operations.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Beniya
+  # Handles file operations (move, copy, delete)
+  class FileOperations
+    # Operation result structure
+    # @return [Hash] { success: Boolean, message: String, count: Integer }
+    OperationResult = Struct.new(:success, :message, :count, :errors, keyword_init: true)
+
+    # Move files/directories to destination
+    # @param items [Array<String>] Item names to move
+    # @param source_directory [String] Source directory path
+    # @param destination [String] Destination directory path
+    # @return [OperationResult]
+    def move(items, source_directory, destination)
+      perform_operation(:move, items, source_directory, destination)
+    end
+
+    # Copy files/directories to destination
+    # @param items [Array<String>] Item names to copy
+    # @param source_directory [String] Source directory path
+    # @param destination [String] Destination directory path
+    # @return [OperationResult]
+    def copy(items, source_directory, destination)
+      perform_operation(:copy, items, source_directory, destination)
+    end
+
+    # Delete files/directories
+    # @param items [Array<String>] Item names to delete
+    # @param source_directory [String] Source directory path
+    # @return [OperationResult]
+    def delete(items, source_directory)
+      success_count = 0
+      error_messages = []
+
+      items.each do |item_name|
+        item_path = File.join(source_directory, item_name)
+
+        begin
+          # Check if file/directory exists
+          unless File.exist?(item_path)
+            error_messages << "#{item_name}: File not found"
+            next
+          end
+
+          is_directory = File.directory?(item_path)
+
+          if is_directory
+            FileUtils.rm_rf(item_path)
+          else
+            FileUtils.rm(item_path)
+          end
+
+          # Verify deletion
+          sleep(0.01) # Wait for file system sync
+          if File.exist?(item_path)
+            error_messages << "#{item_name}: Deletion failed"
+          else
+            success_count += 1
+          end
+        rescue StandardError => e
+          error_messages << "#{item_name}: #{e.message}"
+        end
+      end
+
+      OperationResult.new(
+        success: error_messages.empty?,
+        message: build_delete_message(success_count, items.length),
+        count: success_count,
+        errors: error_messages
+      )
+    end
+
+    # Create a new file
+    # @param directory [String] Directory path
+    # @param filename [String] File name
+    # @return [OperationResult]
+    def create_file(directory, filename)
+      # Validate filename
+      if filename.include?('/') || filename.include?('\\')
+        return OperationResult.new(
+          success: false,
+          message: 'Invalid filename: cannot contain path separators',
+          count: 0,
+          errors: []
+        )
+      end
+
+      file_path = File.join(directory, filename)
+
+      # Check if file already exists
+      if File.exist?(file_path)
+        return OperationResult.new(
+          success: false,
+          message: 'File already exists',
+          count: 0,
+          errors: []
+        )
+      end
+
+      begin
+        File.write(file_path, '')
+        OperationResult.new(
+          success: true,
+          message: "File created: #{filename}",
+          count: 1,
+          errors: []
+        )
+      rescue StandardError => e
+        OperationResult.new(
+          success: false,
+          message: "Creation error: #{e.message}",
+          count: 0,
+          errors: [e.message]
+        )
+      end
+    end
+
+    # Create a new directory
+    # @param parent_directory [String] Parent directory path
+    # @param dirname [String] Directory name
+    # @return [OperationResult]
+    def create_directory(parent_directory, dirname)
+      # Validate dirname
+      if dirname.include?('/') || dirname.include?('\\')
+        return OperationResult.new(
+          success: false,
+          message: 'Invalid directory name: cannot contain path separators',
+          count: 0,
+          errors: []
+        )
+      end
+
+      dir_path = File.join(parent_directory, dirname)
+
+      # Check if directory already exists
+      if File.exist?(dir_path)
+        return OperationResult.new(
+          success: false,
+          message: 'Directory already exists',
+          count: 0,
+          errors: []
+        )
+      end
+
+      begin
+        Dir.mkdir(dir_path)
+        OperationResult.new(
+          success: true,
+          message: "Directory created: #{dirname}",
+          count: 1,
+          errors: []
+        )
+      rescue StandardError => e
+        OperationResult.new(
+          success: false,
+          message: "Creation error: #{e.message}",
+          count: 0,
+          errors: [e.message]
+        )
+      end
+    end
+
+    private
+
+    # Perform move or copy operation
+    # @param operation [Symbol] :move or :copy
+    # @param items [Array<String>] Item names
+    # @param source_directory [String] Source directory path
+    # @param destination [String] Destination directory path
+    # @return [OperationResult]
+    def perform_operation(operation, items, source_directory, destination)
+      success_count = 0
+      error_messages = []
+
+      items.each do |item_name|
+        source_path = File.join(source_directory, item_name)
+        dest_path = File.join(destination, item_name)
+
+        begin
+          if File.exist?(dest_path)
+            error_messages << "#{item_name}: Already exists in destination"
+            next
+          end
+
+          case operation
+          when :move
+            FileUtils.mv(source_path, dest_path)
+          when :copy
+            if File.directory?(source_path)
+              FileUtils.cp_r(source_path, dest_path)
+            else
+              FileUtils.cp(source_path, dest_path)
+            end
+          end
+
+          success_count += 1
+        rescue StandardError => e
+          operation_name = operation == :move ? 'move' : 'copy'
+          error_messages << "#{item_name}: Failed to #{operation_name} (#{e.message})"
+        end
+      end
+
+      operation_name = operation == :move ? 'Moved' : 'Copied'
+      message = "#{operation_name} #{success_count} item(s)"
+      message += " (#{error_messages.length} failed)" unless error_messages.empty?
+
+      OperationResult.new(
+        success: error_messages.empty?,
+        message: message,
+        count: success_count,
+        errors: error_messages
+      )
+    end
+
+    # Build delete operation message
+    # @param success_count [Integer] Number of successfully deleted items
+    # @param total_count [Integer] Total number of items
+    # @return [String]
+    def build_delete_message(success_count, total_count)
+      if success_count == total_count
+        "Deleted #{success_count} item(s)"
+      else
+        failed_count = total_count - success_count
+        "#{success_count} deleted, #{failed_count} failed"
+      end
+    end
+  end
+end

data/lib/beniya/filter_manager.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Beniya
+  # Manages filtering of directory entries
+  class FilterManager
+    attr_reader :filter_query, :filter_mode
+
+    def initialize
+      @filter_mode = false
+      @filter_query = ''
+      @original_entries = []
+      @filtered_entries = []
+    end
+
+    # Start filter mode with the given entries
+    # @param entries [Array<Hash>] Directory entries to filter
+    def start_filter_mode(entries)
+      @filter_mode = true
+      @filter_query = ''
+      @original_entries = entries.dup
+      @filtered_entries = @original_entries.dup
+      true
+    end
+
+    # Handle filter input character
+    # @param key [String] Input key
+    # @return [Symbol] :exit_clear, :exit_keep, :continue, or :backspace_exit
+    def handle_filter_input(key)
+      case key
+      when "\e" # ESC - clear filter and exit
+        :exit_clear
+      when "\r", "\n" # Enter - keep filter and exit
+        :exit_keep
+      when "\u007f", "\b" # Backspace
+        if @filter_query.length > 0
+          @filter_query = @filter_query[0...-1]
+          apply_filter
+          :continue
+        else
+          :backspace_exit
+        end
+      else
+        # Printable characters (alphanumeric, symbols, Japanese, etc.)
+        if key.length == 1 && key.ord >= 32 && key.ord < 127 # ASCII printable
+          @filter_query += key
+          apply_filter
+          :continue
+        elsif key.bytesize > 1 # Multi-byte characters (Japanese, etc.)
+          @filter_query += key
+          apply_filter
+          :continue
+        else
+          # Ignore other keys (Ctrl+c, etc.)
+          :continue
+        end
+      end
+    end
+
+    # Apply filter to entries
+    # @return [Array<Hash>] Filtered entries
+    def apply_filter
+      if @filter_query.empty?
+        @filtered_entries = @original_entries.dup
+      else
+        query_downcase = @filter_query.downcase
+        @filtered_entries = @original_entries.select do |entry|
+          entry[:name].downcase.include?(query_downcase)
+        end
+      end
+      @filtered_entries
+    end
+
+    # Clear filter mode
+    def clear_filter
+      @filter_mode = false
+      @filter_query = ''
+      @filtered_entries = []
+      @original_entries = []
+    end
+
+    # Exit filter mode while keeping the filter
+    def exit_filter_mode_keep_filter
+      @filter_mode = false
+      # Keep @filter_query and @filtered_entries
+    end
+
+    # Check if filter is active
+    # @return [Boolean]
+    def filter_active?
+      @filter_mode || !@filter_query.empty?
+    end
+
+    # Get filtered entries
+    # @return [Array<Hash>]
+    def filtered_entries
+      @filtered_entries
+    end
+
+    # Update original entries (e.g., after directory refresh)
+    # @param entries [Array<Hash>] New entries
+    def update_entries(entries)
+      @original_entries = entries.dup
+      apply_filter if filter_active?
+    end
+
+    # Restart filter mode with existing query
+    # @param entries [Array<Hash>] Directory entries
+    def restart_filter_mode(entries)
+      @filter_mode = true
+      @original_entries = entries.dup if @original_entries.empty?
+      apply_filter
+    end
+  end
+end

data/lib/beniya/logger.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Beniya
+  # Unified logger for debug and error messages
+  # Only logs when BENIYA_DEBUG environment variable is set to '1'
+  class Logger
+    LOG_FILE = File.join(Dir.home, '.beniya_debug.log')
+
+    # Log levels
+    DEBUG = :debug
+    INFO = :info
+    WARN = :warn
+    ERROR = :error
+
+    class << self
+      # Log a debug message with optional context
+      # @param message [String] The log message
+      # @param context [Hash] Additional context information
+      def debug(message, context: {})
+        return unless debug_enabled?
+
+        write_log(DEBUG, message, context)
+      end
+
+      # Log an info message
+      # @param message [String] The log message
+      # @param context [Hash] Additional context information
+      def info(message, context: {})
+        return unless debug_enabled?
+
+        write_log(INFO, message, context)
+      end
+
+      # Log a warning message
+      # @param message [String] The log message
+      # @param context [Hash] Additional context information
+      def warn(message, context: {})
+        return unless debug_enabled?
+
+        write_log(WARN, message, context)
+      end
+
+      # Log an error message with optional exception
+      # @param message [String] The error message
+      # @param exception [Exception, nil] Optional exception object
+      # @param context [Hash] Additional context information
+      def error(message, exception: nil, context: {})
+        return unless debug_enabled?
+
+        full_context = context.dup
+        if exception
+          full_context[:exception] = exception.message
+          full_context[:backtrace] = exception.backtrace&.first(5)
+        end
+
+        write_log(ERROR, message, full_context)
+      end
+
+      # Clear the log file
+      def clear_log
+        return unless debug_enabled?
+
+        File.open(LOG_FILE, 'w') { |f| f.puts "=== Beniya Debug Log Cleared at #{Time.now} ===" }
+      end
+
+      private
+
+      # Check if debug logging is enabled
+      # @return [Boolean]
+      def debug_enabled?
+        ENV['BENIYA_DEBUG'] == '1'
+      end
+
+      # Write a log entry to the log file
+      # @param level [Symbol] Log level
+      # @param message [String] Log message
+      # @param context [Hash] Context information
+      def write_log(level, message, context)
+        File.open(LOG_FILE, 'a') do |f|
+          timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S')
+          f.puts "[#{timestamp}] [#{level.to_s.upcase}] #{message}"
+
+          unless context.empty?
+            f.puts '  Context:'
+            context.each do |key, value|
+              if value.is_a?(Array) && value.length > 10
+                f.puts "    #{key}: [#{value.length} items]"
+              else
+                f.puts "    #{key}: #{value.inspect}"
+              end
+            end
+          end
+
+          f.puts ''
+        end
+      rescue StandardError => e
+        # Silently fail if we can't write to log file
+        # Don't want logging to break the application
+        warn "Failed to write to log file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/beniya/selection_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Beniya
+  # Manages selected items (files/directories) for bulk operations
+  class SelectionManager
+    def initialize
+      @selected_items = []
+    end
+
+    # Toggle selection for an entry
+    # @param entry [Hash] Entry with :name key
+    # @return [Boolean] true if now selected, false if unselected
+    def toggle_selection(entry)
+      return false unless entry
+
+      if @selected_items.include?(entry[:name])
+        @selected_items.delete(entry[:name])
+        false
+      else
+        @selected_items << entry[:name]
+        true
+      end
+    end
+
+    # Check if an entry is selected
+    # @param entry_name [String] Entry name
+    # @return [Boolean]
+    def selected?(entry_name)
+      @selected_items.include?(entry_name)
+    end
+
+    # Get all selected items
+    # @return [Array<String>] Copy of selected items
+    def selected_items
+      @selected_items.dup
+    end
+
+    # Clear all selections
+    def clear
+      @selected_items.clear
+    end
+
+    # Check if any items are selected
+    # @return [Boolean]
+    def any?
+      !@selected_items.empty?
+    end
+
+    # Get the count of selected items
+    # @return [Integer]
+    def count
+      @selected_items.length
+    end
+
+    # Add an item to selection
+    # @param item_name [String] Item name
+    def add(item_name)
+      @selected_items << item_name unless @selected_items.include?(item_name)
+    end
+
+    # Remove an item from selection
+    # @param item_name [String] Item name
+    def remove(item_name)
+      @selected_items.delete(item_name)
+    end
+
+    # Select multiple items
+    # @param item_names [Array<String>] Item names
+    def select_multiple(item_names)
+      item_names.each { |name| add(name) }
+    end
+
+    # Check if selection is empty
+    # @return [Boolean]
+    def empty?
+      @selected_items.empty?
+    end
+  end
+end

data/lib/beniya/text_utils.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Beniya
+  # Text utility methods for display width calculation and string manipulation
+  # Handles multi-byte characters (Japanese, etc.) correctly
+  module TextUtils
+    module_function
+
+    # Character width constants
+    FULLWIDTH_CHAR_WIDTH = 2
+    HALFWIDTH_CHAR_WIDTH = 1
+    MULTIBYTE_THRESHOLD = 1
+
+    # Truncation constants
+    ELLIPSIS_MIN_WIDTH = 3
+    ELLIPSIS = '...'
+
+    # Line break constants
+    BREAK_POINT_THRESHOLD = 0.5  # Break after 50% of max_width
+
+    # Calculate display width of a string
+    # Full-width characters (Japanese, etc.) count as 2, half-width as 1
+    def display_width(string)
+      string.each_char.map do |char|
+        case char
+        when /[\u3000-\u303F\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF\uFF00-\uFFEF]/
+          FULLWIDTH_CHAR_WIDTH  # Japanese characters (hiragana, katakana, kanji, full-width symbols)
+        when /[\u0020-\u007E]/
+          HALFWIDTH_CHAR_WIDTH  # ASCII characters
+        else
+          char.bytesize > MULTIBYTE_THRESHOLD ? FULLWIDTH_CHAR_WIDTH : HALFWIDTH_CHAR_WIDTH
+        end
+      end.sum
+    end
+
+    # Truncate string to fit within max_width
+    def truncate_to_width(string, max_width)
+      return string if display_width(string) <= max_width
+
+      result = ''
+      current_width = 0
+
+      string.each_char do |char|
+        char_width = display_width(char)
+        break if current_width + char_width > max_width
+
+        result += char
+        current_width += char_width
+      end
+
+      # Add ellipsis if there's room
+      result += ELLIPSIS if max_width >= ELLIPSIS_MIN_WIDTH && current_width <= max_width - ELLIPSIS_MIN_WIDTH
+      result
+    end
+
+    # Pad string to target_width with spaces
+    def pad_string_to_width(string, target_width)
+      current_width = display_width(string)
+      if current_width >= target_width
+        truncate_to_width(string, target_width)
+      else
+        string + ' ' * (target_width - current_width)
+      end
+    end
+
+    # Find the best break point for wrapping text within max_width
+    def find_break_point(line, max_width)
+      return line.length if display_width(line) <= max_width
+
+      current_width = 0
+      best_break_point = 0
+      space_break_point = nil
+      punct_break_point = nil
+
+      line.each_char.with_index do |char, index|
+        char_width = display_width(char)
+        break if current_width + char_width > max_width
+
+        current_width += char_width
+        best_break_point = index + 1
+
+        # Record break point at space
+        space_break_point = index + 1 if char == ' ' && current_width > max_width * BREAK_POINT_THRESHOLD
+
+        # Record break point at Japanese punctuation
+        punct_break_point = index + 1 if char.match?(/[、。，．！？]/) && current_width > max_width * BREAK_POINT_THRESHOLD
+      end
+
+      space_break_point || punct_break_point || best_break_point
+    end
+  end
+end

data/lib/beniya/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Beniya
-  VERSION = '0.6.1'
+  VERSION = '0.6.2'
 end

data/lib/beniya/zoxide_integration.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Beniya
+  # Integrates with zoxide for directory history navigation
+  class ZoxideIntegration
+    # Dialog size constants
+    DIALOG_WIDTH = 45
+    DIALOG_BORDER_HEIGHT = 4
+
+    def initialize(dialog_renderer = nil)
+      @dialog_renderer = dialog_renderer
+    end
+
+    # Check if zoxide is available
+    # @return [Boolean]
+    def available?
+      system('which zoxide > /dev/null 2>&1')
+    end
+
+    # Get zoxide history
+    # @return [Array<Hash>] Array of { path: String, score: Float }
+    def get_history
+      return [] unless available?
+
+      begin
+        # Get zoxide history with scores
+        output = `zoxide query --list --score 2>/dev/null`.strip
+        return [] if output.empty?
+
+        # Parse each line into path and score
+        lines = output.split("\n")
+        history = lines.map do |line|
+          # zoxide output format: "score path"
+          if line.match(/^\s*(\d+(?:\.\d+)?)\s+(.+)$/)
+            score = ::Regexp.last_match(1).to_f
+            path = ::Regexp.last_match(2).strip
+            { path: path, score: score }
+          else
+            # No score (backward compatibility)
+            { path: line.strip, score: 0.0 }
+          end
+        end
+
+        # Filter to only existing directories
+        history.select { |entry| Dir.exist?(entry[:path]) }
+      rescue StandardError
+        []
+      end
+    end
+
+    # Show zoxide history menu and let user select
+    # @return [String, nil] Selected path or nil if cancelled
+    def show_menu
+      return nil unless @dialog_renderer
+
+      history = get_history
+
+      if history.empty?
+        show_no_history_message
+        return nil
+      end
+
+      select_from_history(history)
+    end
+
+    # Add directory to zoxide history
+    # @param path [String] Directory path
+    # @return [Boolean] Success status
+    def add_to_history(path)
+      return false unless available?
+      return false unless Dir.exist?(path)
+
+      begin
+        system("zoxide add #{Shellwords.escape(path)} > /dev/null 2>&1")
+        true
+      rescue StandardError
+        false
+      end
+    end
+
+    private
+
+    # Show message when no history is available
+    def show_no_history_message
+      return unless @dialog_renderer
+
+      title = 'Zoxide'
+      content_lines = [
+        '',
+        'No zoxide history found.',
+        '',
+        'Zoxide learns from your directory navigation.',
+        'Use zoxide more to build up history.',
+        '',
+        'Press any key to continue...'
+      ]
+
+      dialog_width = DIALOG_WIDTH
+      dialog_height = DIALOG_BORDER_HEIGHT + content_lines.length
+      x, y = @dialog_renderer.calculate_center(dialog_width, dialog_height)
+
+      @dialog_renderer.draw_floating_window(x, y, dialog_width, dialog_height, title, content_lines, {
+                                               border_color: "\e[33m", # Yellow
+                                               title_color: "\e[1;33m",   # Bold yellow
+                                               content_color: "\e[37m"    # White
+                                             })
+
+      STDIN.getch
+      @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+    end
+
+    # Select from zoxide history
+    # @param history [Array<Hash>] History entries
+    # @return [String, nil] Selected path or nil
+    def select_from_history(history)
+      return nil unless @dialog_renderer
+
+      title = 'Zoxide History'
+
+      # Format history for display (max 20 items)
+      display_history = history.first(20)
+      content_lines = ['']
+
+      display_history.each_with_index do |entry, index|
+        # Shorten path display (replace home directory with ~)
+        display_path = entry[:path].gsub(ENV['HOME'], '~')
+        line = "  #{index + 1}. #{display_path}"
+        # Truncate if too long
+        line = line[0...60] + '...' if line.length > 63
+        content_lines << line
+      end
+
+      content_lines << ''
+      content_lines << 'Enter number (1-' + display_history.length.to_s + ') or ESC to cancel'
+
+      dialog_width = 70
+      dialog_height = [4 + content_lines.length, 25].min
+      x, y = @dialog_renderer.calculate_center(dialog_width, dialog_height)
+
+      @dialog_renderer.draw_floating_window(x, y, dialog_width, dialog_height, title, content_lines, {
+                                               border_color: "\e[36m", # Cyan
+                                               title_color: "\e[1;36m",   # Bold cyan
+                                               content_color: "\e[37m"    # White
+                                             })
+
+      # Number input mode
+      input_buffer = ''
+
+      loop do
+        char = STDIN.getch
+
+        case char
+        when "\e", "\x03" # ESC, Ctrl+C
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          return nil
+        when "\r", "\n" # Enter
+          unless input_buffer.empty?
+            number = input_buffer.to_i
+            if number > 0 && number <= display_history.length
+              selected_entry = display_history[number - 1]
+              @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+              return selected_entry[:path]
+            end
+          end
+          # Invalid input, ask again
+          input_buffer = ''
+        when "\u007f", "\b" # Backspace
+          input_buffer = input_buffer[0...-1] unless input_buffer.empty?
+        when /[0-9]/
+          input_buffer += char
+          # Max 2 digits
+          input_buffer = input_buffer[-2..-1] if input_buffer.length > 2
+
+          # If number is within range, select immediately
+          number = input_buffer.to_i
+          if number > 0 && number <= display_history.length &&
+             (number >= 10 || input_buffer.length == 1)
+            selected_entry = display_history[number - 1]
+            @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+            return selected_entry[:path]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/beniya.rb

@@ -5,6 +5,15 @@ require_relative "beniya/config"
 require_relative "beniya/config_loader"
 require_relative "beniya/color_helper"
 require_relative "beniya/directory_listing"
+require_relative "beniya/filter_manager"
+require_relative "beniya/selection_manager"
+require_relative "beniya/file_operations"
+require_relative "beniya/bookmark_manager"
+require_relative "beniya/bookmark"
+require_relative "beniya/zoxide_integration"
+require_relative "beniya/dialog_renderer"
+require_relative "beniya/text_utils"
+require_relative "beniya/logger"
 require_relative "beniya/keybind_handler"
 require_relative "beniya/file_preview"
 require_relative "beniya/terminal_ui"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: beniya
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.2
 platform: ruby
 authors:
 - masisz
 bindir: bin
 cert_chain: []
-date: 2025-10-19 00:00:00.000000000 Z
+date: 2025-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: io-console
@@ -129,16 +129,24 @@ files:
 - lib/beniya.rb
 - lib/beniya/application.rb
 - lib/beniya/bookmark.rb
+- lib/beniya/bookmark_manager.rb
 - lib/beniya/color_helper.rb
 - lib/beniya/config.rb
 - lib/beniya/config_loader.rb
+- lib/beniya/dialog_renderer.rb
 - lib/beniya/directory_listing.rb
 - lib/beniya/file_opener.rb
+- lib/beniya/file_operations.rb
 - lib/beniya/file_preview.rb
+- lib/beniya/filter_manager.rb
 - lib/beniya/health_checker.rb
 - lib/beniya/keybind_handler.rb
+- lib/beniya/logger.rb
+- lib/beniya/selection_manager.rb
 - lib/beniya/terminal_ui.rb
+- lib/beniya/text_utils.rb
 - lib/beniya/version.rb
+- lib/beniya/zoxide_integration.rb
 - publish_gem.zsh
 - test_delete/test1.txt
 - test_delete/test2.txt