rtfm-filemanager 8.2.0 → 8.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef7c28629f7646f129d96e76afd871a7ab6030e0adb9983055a247ccc3992ecc
-  data.tar.gz: b1c7f85c145f532f5e3175c5fb2f4642d134149d147fc06b4a26389f25d1f42c
+  metadata.gz: eb02bbf2f12ccc66afd6d2fbbef68f6e7a1a05f3d932e48a8143ae8df1a70d39
+  data.tar.gz: e1a1583ccab118308ecf16d898631dff1fcddedb3b46f7462ba2a8486cfad5d1
 SHA512:
-  metadata.gz: 9207a4adaeed8a14f3a7a78a70fafdcba2318635605406168679aefe6f2e859cedc7c4053ebcf0d08f610415874df41f061fedad1fd41955cbcc7ae1eb2206a9
-  data.tar.gz: 1c8b70f11a2436b5beedebf1b0a510395e62e93a99ed1050192f381097693816731864f46c86a22eeebb8139ae9bb09367625c01ad9856142cffb2b271fdb53d
+  metadata.gz: 8eaeb2806d03dd15601d705bc409b677cbbb3bbe08aa69a1cd8b9135bbf4b5ecfc95c8140b4c9d9e526eb4652fa9057f4102aec05058d6c94272b39027d3e33a
+  data.tar.gz: f9cb7747b1c773a2c545bb1afaa600ceff1a04d13149d9a98cae029687a37cbeccb0b330951659463fd666206104234d5ae0f6298c5cef2ff01d3950be9063ae

data/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to RTFM will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [8.2.1] - 2026-03-16
+
+### Added
+- **Trash browser** (`D` key) - Browse trash contents with timestamps and original paths. Restore files, permanently delete individual items, or empty all trash
+- **Disk usage plugin** (`S` key) - Interactive size-sorted directory analyzer with visual bars and cancellable scanning
+- **Duplicate finder plugin** (`F7`) - Find duplicate files by content hash with tag-to-keep workflow and cancellable scanning
+
+### Fixed
+- **Right pane scrolling** - Shift-Down/Up now works after displaying content via `say` (marks, help, system info, etc.)
+- **rcurses pane refresh** - No longer queries cursor position via stdin (uses ANSI save/restore), preventing keypresses from being consumed during progress updates
+
 ## [8.2.0] - 2026-03-15
 
 ### Added

data/README.md

@@ -211,7 +211,7 @@ For complete reference: `man rtfm` or press `?` in RTFM
 | `c` | Rename item |
 | `E` | Bulk rename (patterns) |
 | `d` | Delete (→ trash if enabled) |
-| `D` | Empty trash |
+| `D` | Trash browser (browse, restore, delete) |
 | `Ctrl-d` | Toggle trash on/off |
 | `U` | Undo last operation |
 
@@ -515,6 +515,8 @@ cp examples/git.rb ~/.rtfm/plugins/
 cp examples/bookmarks.rb ~/.rtfm/plugins/
 cp examples/notes.rb ~/.rtfm/plugins/
 cp examples/opener.rb ~/.rtfm/plugins/
+cp examples/diskusage.rb ~/.rtfm/plugins/
+cp examples/dupes.rb ~/.rtfm/plugins/
 ```
 
 | Plugin | Key | Description |
@@ -524,6 +526,8 @@ cp examples/opener.rb ~/.rtfm/plugins/
 | **Bookmarks** | `F6` | Unlimited directory bookmarks with fuzzy filtering. Add, delete, and jump to bookmarked directories. Complements the built-in single-letter marks (m/') |
 | **Notes** | `F5` | Attach text notes to any file or directory. View, edit, or delete notes. Stored in `~/.rtfm/notes/` |
 | **Opener** | `RIGHT`/`l` | Custom file openers by extension. Configure a hash of extension-to-command mappings (e.g., `.hl` files open in hyperlist) |
+| **Disk Usage** | `S` | Interactive disk usage analyzer. Extends system info with a browseable size-sorted directory view with visual bars |
+| **Dupes** | `F7` | Find duplicate files by content hash. Two-pass scan (size then SHA256) with in-place deletion of duplicates |
 
 ### Writing Your Own Plugins
 
@@ -692,7 +696,8 @@ Best image experience with: kitty, urxvt, xterm, mlterm, foot
 ### Version 8.2 Highlights
 
 - **Plugin system with live enable/disable** - Plugins in `~/.rtfm/plugins/` are auto-loaded on startup. Toggle them on and off at runtime with the plugin manager (`V` key), no restart needed. Each plugin can register help text viewable with `?`.
-- **Five example plugins** - Settings editor, git operations, directory bookmarks, file notes, and custom file openers. Copy from `examples/` to `~/.rtfm/plugins/` to use.
+- **Seven example plugins** - Settings editor, git operations, directory bookmarks, file notes, custom file openers, disk usage analyzer, and duplicate file finder. Copy from `examples/` to `~/.rtfm/plugins/` to use.
+- **Trash browser** (`D` key) - Browse trash contents with timestamps and original paths. Restore files to their original location, permanently delete individual items, or empty all trash.
 
 ### Version 8.1 Highlights
 

data/bin/rtfm

@@ -18,7 +18,7 @@
 #             get a great understanding of the code itself by simply sending
 #             or pasting this whole file into you favorite AI for coding with
 #             a prompt like this: "Help me understand every part of this code".
-@version    = '8.2.0' # Plugin system with live enable/disable and built-in plugin manager
+@version    = '8.2.1' # Trash browser, right pane scroll fix, plugin improvements
 
 # SAVE & STORE TERMINAL {{{1
 ORIG_STTY = `stty -g`.chomp
@@ -242,7 +242,7 @@ CONFIG_FILE   = File.join(RTFM_HOME, 'conf')
     s       = Create symlink to tagged items here
     d       = Delete selected item and tagged items. Confirm with 'y'. 
               Moves items to trash directory (~/.rtfm/trash/) if @trash = true
-    D       = Empty trash directory
+    D       = Trash browser (browse, restore, delete, empty trash)
     Ctrl-d  = Toggle use of trash directory
 
   UNDO OPERATIONS
@@ -4204,14 +4204,152 @@ def empty_trash # {{{3
     remote_download_selected
     return
   end
-  @pB.say(" Really empty Trash (~/.rtfm/trash)? (press 'y')")
-  return unless  getchr == 'y'
+  trash_browser
+end
+
+def trash_browser # TRASH BROWSER {{{3
+  clear_image
+  sel = 0
+  offset = 0
+
+  loop do
+    # Scan trash directory, build item list with metadata
+    raw = Dir.entries(TRASH_DIR).reject { |e| e == '.' || e == '..' }.map { |e| File.join(TRASH_DIR, e) }
+    entries = raw.select { |f| File.exist?(f) || File.symlink?(f) }
+    entries.sort_by! { |f| File.mtime(f) rescue Time.at(0) }
+    entries.reverse!
+    items = entries.filter_map do |f|
+      basename = File.basename(f)
+      orig_name = basename.sub(/^\d{8}_\d{6}_/, '').sub(/_\d{4}$/, '')
+      orig_path = nil
+      @undo_history.each do |op|
+        next unless op[:type] == 'delete' && op[:trash]
+        op[:paths].each { |p| orig_path = p[:path] if p[:trash_name] == basename }
+      end
+      begin
+        size = File.directory?(f) ? (command("du -sb #{Shellwords.escape(f)} 2>/dev/null").split.first.to_i rescue 0) : File.size(f)
+        mtime = File.mtime(f)
+      rescue
+        size = 0
+        mtime = Time.at(0)
+      end
+      { path: f, basename: basename, orig_name: orig_name, orig_path: orig_path,
+        size: size, mtime: mtime, dir: File.directory?(f) }
+    end
+
+    sel = [sel, items.size - 1, 0].sort[1]
+    page_h = @pR.h - 5
+    page_h = 1 if page_h < 1
+    offset = sel - page_h + 1 if sel >= offset + page_h
+    offset = sel if sel < offset
+    offset = 0 if offset < 0
+    visible = items[offset, page_h] || []
 
-  command("rm -rf #{TRASH_DIR}/*")
-  @pB.say('Trash is now empty')
+    lines = []
+    lines << "j/k:move  r:restore  d:delete  E:empty all  q:close".fg(240)
+    lines << "Trash".b.fg(254) + "  (#{items.size} items)".fg(240)
+    lines << ""
+
+    if items.empty?
+      lines << "Trash is empty.".fg(240)
+    else
+      visible.each_with_index do |item, i|
+        idx = offset + i
+        size_s = human_size(item[:size])
+        type_indicator = item[:dir] ? "/".fg(69) : ""
+        age = time_ago(item[:mtime])
+        name = item[:orig_name] + type_indicator
+        origin = item[:orig_path] ? "  #{File.dirname(item[:orig_path])}".fg(240) : ""
+        line = "#{size_s.rjust(8).fg(249)} #{age.rjust(6).fg(240)} #{name}#{origin}"
+        line = idx == sel ? line.u : line
+        lines << line
+      end
+      lines << "(#{sel + 1}/#{items.size})".fg(240) if items.size > page_h
+    end
+
+    @pR.update = true
+    @pR.say(lines.join("\n"))
+
+    chr = getchr
+    case chr
+    when 'q', 'ESC'
+      break
+    when 'j', 'DOWN'
+      sel = items.empty? ? 0 : (sel + 1) % items.size
+    when 'k', 'UP'
+      sel = items.empty? ? 0 : (sel - 1) % items.size
+    when 'r'
+      next if items.empty?
+      item = items[sel]
+      if item[:orig_path]
+        dest = item[:orig_path]
+      else
+        dest = @pCmd.ask('Restore to: ', File.join(Dir.pwd, item[:orig_name]))
+      end
+      next if dest.strip.empty?
+      if File.exist?(dest)
+        @pB.say("Destination exists: #{dest}".fg(196))
+        next
+      end
+      begin
+        FileUtils.mv(item[:path], dest)
+        # Remove from undo history
+        @undo_history.each do |op|
+          next unless op[:type] == 'delete' && op[:trash]
+          op[:paths].reject! { |p| p[:trash_name] == item[:basename] }
+        end
+        @pB.say("Restored: #{File.basename(dest)}".fg(156))
+        sel = [sel - 1, 0].max
+      rescue => e
+        @pB.say("Restore failed: #{e.message}".fg(196))
+      end
+    when 'd'
+      next if items.empty?
+      item = items[sel]
+      @pB.say(" Permanently delete #{item[:orig_name]}? (y/n)".fg(196))
+      if getchr == 'y'
+        command("rm -rf #{Shellwords.escape(item[:path])}")
+        @pB.say("Deleted: #{item[:orig_name]}".fg(204))
+        sel = [sel - 1, 0].max
+      end
+    when 'E'
+      @pB.say(" Empty ALL trash? This cannot be undone! (y/n)".fg(196))
+      if getchr == 'y'
+        command("rm -rf #{TRASH_DIR}/*")
+        @undo_history.reject! { |op| op[:type] == 'delete' && op[:trash] }
+        @pB.say("Trash emptied.".fg(204))
+        sel = 0
+      end
+    end
+  end
+
+  @pR.update = true
+  refresh
   render
 end
 
+def human_size(bytes) # {{{3
+  if bytes >= 1_073_741_824
+    "%.1fG" % (bytes / 1_073_741_824.0)
+  elsif bytes >= 1_048_576
+    "%.1fM" % (bytes / 1_048_576.0)
+  elsif bytes >= 1024
+    "%.1fK" % (bytes / 1024.0)
+  else
+    "#{bytes}B"
+  end
+end
+
+def time_ago(time) # {{{3
+  seconds = Time.now - time
+  if seconds < 60 then "now"
+  elsif seconds < 3600 then "#{(seconds / 60).to_i}m"
+  elsif seconds < 86400 then "#{(seconds / 3600).to_i}h"
+  elsif seconds < 604800 then "#{(seconds / 86400).to_i}d"
+  else "#{(seconds / 604800).to_i}w"
+  end
+end
+
 def toggle_trash # {{{3
   @trash = !@trash
   @pB.say("Trash (~/.rtfm/trash) = #{@trash ? 'On' : 'Off'}")
@@ -4720,19 +4858,19 @@ def refresh_right # {{{3
 end
 
 def line_down_right # {{{3
-  @pR.linedown; @pB.update = true
+  @pR.update = true; @pR.linedown; @pR.update = false; @pB.update = true
 end
 
 def line_up_right # {{{3
-  @pR.lineup;   @pB.update = true
+  @pR.update = true; @pR.lineup; @pR.update = false; @pB.update = true
 end
 
 def page_down_right # {{{3
-  @pR.pagedown; @pB.update = true
+  @pR.update = true; @pR.pagedown; @pR.update = false; @pB.update = true
 end
 
 def page_up_right # {{{3
-  @pR.pageup; @pB.update = true
+  @pR.update = true; @pR.pageup; @pR.update = false; @pB.update = true
 end
 
 # CLIPBOARD COPY {{{2

data/examples/diskusage.rb

@@ -0,0 +1,199 @@
+# @name: Disk Usage
+# @description: Interactive disk usage analyzer for current directory
+# @key: S (extends system info)
+
+KEYMAP['S'] = :diskusage_menu
+
+PLUGIN_HELP['Disk Usage'] = <<~HELP
+  Interactive disk usage analyzer for the current directory.
+
+  Press S to open the system/disk usage menu.
+
+  #{"Menu:".b}
+    s   Show system info (original S behavior)
+    d   Open disk usage analyzer
+
+  #{"Disk Usage Analyzer:".b}
+    j/k       Navigate up/down
+    ENTER     Drill into selected directory
+    LEFT/h    Go up to parent directory
+    q/ESC     Close analyzer
+
+  Scanning can be cancelled with ESC. The analyzer
+  shows all files and directories sorted by size
+  (largest first), with visual bars and human-readable
+  sizes. Directories are shown in blue.
+HELP
+
+def diskusage_menu
+  clear_image
+
+  lines = []
+  lines << "System / Disk Usage".b.fg(254)
+  lines << ""
+  lines << "s".b.fg(112) + "  System info"
+  lines << "d".b.fg(112) + "  Disk usage analyzer"
+  lines << ""
+  lines << "q/ESC: close".fg(240)
+
+  @pR.update = true
+  @pR.say(lines.join("\n"))
+
+  chr = getchr
+  case chr
+  when 's'
+    system_info
+  when 'd'
+    diskusage_browse(Dir.pwd)
+  when 'q', 'ESC'
+    @pR.update = true
+    refresh
+    render
+  end
+end
+
+def diskusage_browse(start_dir)
+  browse_dir = start_dir
+  sel = 0
+  offset = 0
+  cached = {} # dir => entries
+
+  loop do
+    entries = cached[browse_dir] || diskusage_scan(browse_dir)
+    cached[browse_dir] = entries if entries
+    entries ||= []
+    total = entries.sum { |e| e[:size] }
+    max_size = entries.map { |e| e[:size] }.max || 1
+    page_h = @pR.h - 6
+    page_h = 1 if page_h < 1
+
+    sel = 0 if entries.empty?
+    sel = entries.size - 1 if sel >= entries.size && !entries.empty?
+
+    offset = sel - page_h + 1 if sel >= offset + page_h
+    offset = sel if sel < offset
+    offset = 0 if offset < 0
+
+    visible = entries[offset, page_h] || []
+
+    lines = []
+    lines << "Disk Usage".b.fg(254) + "  " + browse_dir.fg(240)
+    lines << ("Total: " + diskusage_human(total)).fg(249)
+    lines << ""
+
+    bar_width = @pR.w - 30
+    bar_width = 10 if bar_width < 10
+
+    visible.each_with_index do |entry, i|
+      idx = offset + i
+      ratio = max_size > 0 ? entry[:size].to_f / max_size : 0
+      filled = (ratio * bar_width).round
+      bar = "\u2588" * filled + "\u2591" * (bar_width - filled)
+
+      name_color = entry[:dir] ? 69 : 249
+      size_str = diskusage_human(entry[:size]).rjust(9)
+      name = entry[:name]
+      name += "/" if entry[:dir]
+
+      line = bar.fg(entry[:dir] ? 69 : 243) + " " +
+             size_str.fg(156) + " " +
+             name.fg(name_color)
+      line = idx == sel ? line.u : line
+      lines << line
+    end
+
+    if entries.size > page_h
+      lines << ""
+      lines << "(#{sel + 1}/#{entries.size})".fg(240)
+    end
+
+    @pR.update = true
+    @pR.say(lines.join("\n"))
+
+    chr = getchr
+    case chr
+    when 'j', 'DOWN'
+      sel = (sel + 1) % entries.size unless entries.empty?
+    when 'k', 'UP'
+      sel = (sel - 1) % entries.size unless entries.empty?
+    when 'ENTER'
+      next if entries.empty?
+      entry = entries[sel]
+      if entry[:dir]
+        browse_dir = File.join(browse_dir, entry[:name])
+        sel = 0
+        offset = 0
+      end
+    when 'LEFT', 'h'
+      parent = File.dirname(browse_dir)
+      if parent != browse_dir
+        browse_dir = parent
+        sel = 0
+        offset = 0
+      end
+    when 'q', 'ESC'
+      break
+    end
+  end
+
+  @pR.update = true
+  refresh
+  render
+end
+
+def diskusage_scan(dir)
+  return [] unless Dir.exist?(dir)
+
+  entries = []
+  # Scan entries one by one for progress and cancellability
+  children = begin
+    Dir.entries(dir).reject { |e| e == '.' || e == '..' }
+  rescue
+    return []
+  end
+
+  children.each_with_index do |name, i|
+    # Check for ESC to cancel
+    begin
+      $stdin.read_nonblock(1)
+      $stdin.read_nonblock(16) rescue nil
+      @pB.say("Scan cancelled.".fg(220))
+      return entries.sort_by { |e| -e[:size] }
+    rescue IO::WaitReadable, EOFError
+      # No keypress, continue scanning
+    end
+
+    @pB.update = true
+    @pB.say(" Scanning #{i + 1}/#{children.size}: #{name}")
+    @pB.refresh
+
+    path = File.join(dir, name)
+    is_dir = File.directory?(path) rescue false
+    begin
+      if is_dir
+        out = `du -sb #{Shellwords.escape(path)} 2>/dev/null`.strip
+        size = out.split("\t").first.to_i
+      else
+        size = File.size(path) rescue 0
+      end
+    rescue
+      size = 0
+    end
+    entries << { name: name, size: size, dir: is_dir }
+  end
+
+  @pB.say("")
+  entries.sort_by { |e| -e[:size] }
+end
+
+def diskusage_human(bytes)
+  if bytes >= 1024 * 1024 * 1024
+    format("%.1f GB", bytes.to_f / (1024 * 1024 * 1024))
+  elsif bytes >= 1024 * 1024
+    format("%.1f MB", bytes.to_f / (1024 * 1024))
+  elsif bytes >= 1024
+    format("%.1f KB", bytes.to_f / 1024)
+  else
+    "#{bytes} B"
+  end
+end

data/examples/dupes.rb

@@ -0,0 +1,335 @@
+# @name: Dupes
+# @description: Find duplicate files by content hash in current directory
+# @key: F7
+
+require 'digest'
+require 'shellwords'
+
+KEYMAP['F7'] = :find_dupes
+
+PLUGIN_HELP['Dupes'] = <<~HELP
+  Find duplicate files by content hash.
+
+  Press F7 to scan the current directory for files
+  that share identical content.
+
+  #{"Scanning:".b}
+    Files are first grouped by size, then only
+    same-size files are hashed (SHA256) to confirm
+    duplicates. Press 'r' at the start prompt to
+    scan recursively.
+
+  #{"Navigation:".b}
+    j/k         Move between duplicate groups
+    PgDn/PgUp   Jump 10 groups
+    LEFT/RIGHT  Move between files in a group
+    t           Tag file to KEEP
+    d           Delete all untagged files in group
+    q/ESC       Close
+
+  #{"Deletion:".b}
+    If trash mode is enabled, deleted files are
+    moved to the trash and can be undone. Otherwise
+    files are permanently removed.
+
+  #{"Display:".b}
+    Groups are sorted by wasted space (largest
+    first). Each group shows a partial hash, file
+    size, and the list of duplicate paths.
+HELP
+
+def find_dupes
+  clear_image
+
+  @pB.say("Scan duplicates: ENTER=current dir, r=recursive, q=cancel")
+  chr = getchr
+  return if chr == 'q' || chr == 'ESC'
+  recursive = (chr == 'r')
+
+  dupes_progress("Collecting files#{recursive ? ' recursively' : ''}... (any key to cancel)")
+
+  # Collect files with cancellation support
+  all_files = []
+  cancelled = false
+  if recursive
+    dirs = [Dir.pwd]
+    while dirs.any?
+      break if cancelled
+      dir = dirs.shift
+      begin
+        Dir.foreach(dir) do |entry|
+          next if entry == '.' || entry == '..'
+          path = File.join(dir, entry)
+          if File.directory?(path) && !File.symlink?(path)
+            dirs << path
+          elsif File.file?(path) && !File.symlink?(path)
+            all_files << path
+          end
+          if all_files.size % 200 == 0
+            dupes_progress("Collecting: #{all_files.size} files... (any key to cancel)")
+            if dupes_cancelled?
+              cancelled = true
+              break
+            end
+          end
+        end
+      rescue Errno::EACCES, Errno::ENOENT
+        next
+      end
+    end
+  else
+    Dir.foreach(Dir.pwd) do |entry|
+      next if entry == '.' || entry == '..'
+      path = File.join(Dir.pwd, entry)
+      all_files << path if File.file?(path) && !File.symlink?(path)
+    end
+  end
+
+  if cancelled && all_files.empty?
+    @pB.say("Scan cancelled.")
+    return
+  end
+
+  if all_files.empty?
+    @pB.say("No files found.")
+    return
+  end
+
+  # Pass 1: group by size (with cancellation)
+  by_size = {}
+  all_files.each_with_index do |f, i|
+    if i % 500 == 0
+      dupes_progress("Pass 1/2: sizing #{i}/#{all_files.size}... (any key to cancel)")
+      if dupes_cancelled?
+        cancelled = true
+        break
+      end
+    end
+    begin
+      sz = File.size(f)
+      (by_size[sz] ||= []) << f
+    rescue
+      next
+    end
+  end
+  by_size.delete(0)
+  candidates = by_size.values.select { |g| g.size > 1 }
+
+  if candidates.empty?
+    @pB.say(cancelled ? "Scan cancelled. No duplicates in partial results." : "No duplicate candidates (all files have unique sizes).")
+    return
+  end
+
+  # Pass 2: hash same-size files (with cancellation)
+  total = candidates.sum(&:size)
+  done = 0
+  by_hash = {}
+  candidates.each do |group|
+    break if cancelled
+    group.each do |f|
+      done += 1
+      if done % 10 == 1 || done == total
+        dupes_progress("Pass 2/2: hashing #{done}/#{total}... (any key to cancel)")
+        if IO.select([$stdin], nil, nil, 0)
+          $stdin.read_nonblock(16) rescue nil
+          cancelled = true
+          break
+        end
+      end
+      begin
+        digest = Digest::SHA256.new
+        File.open(f, 'rb') do |io|
+          buf = String.new(capacity: 65536)
+          while io.read(65536, buf)
+            digest.update(buf)
+          end
+        end
+        hex = digest.hexdigest
+        (by_hash[hex] ||= []) << f
+      rescue
+        next
+      end
+    end
+  end
+
+  if cancelled
+    @pB.say("Scan cancelled. Showing partial results...")
+  end
+
+  dupes = by_hash.values.select { |g| g.size > 1 }
+
+  if dupes.empty?
+    @pB.say("No duplicates found (same-size files had different content).")
+    return
+  end
+
+  # Sort by wasted space descending
+  dupes.sort_by! { |g| -(File.size(g[0]) * (g.size - 1)) rescue 0 }
+
+  # Precompute group metadata
+  group_meta = dupes.map do |group|
+    sz = File.size(group[0]) rescue 0
+    { size: sz, waste: sz * (group.size - 1) }
+  end
+  wasted_total = group_meta.sum { |m| m[:waste] }
+
+  group_idx = 0
+  file_idx = 0
+  kept = {} # group_idx => Set of file indices to keep
+
+  loop do
+    group = dupes[group_idx]
+    meta = group_meta[group_idx]
+    kept[group_idx] ||= []
+
+    lines = []
+    lines << "j/k:group  LEFT/RIGHT:file  t:keep  d:delete untagged  q:close".fg(240)
+    lines << "Duplicate Files".b.fg(254) + "  (#{group_idx + 1}/#{dupes.size} groups, #{format_bytes(wasted_total)} wasted)".fg(240)
+    lines << ""
+
+    header = "#{format_bytes(meta[:size])} x#{group.size} (#{format_bytes(meta[:waste])} wasted)"
+    lines << header.b.fg(112)
+
+    group.each_with_index do |f, fi|
+      rel = f.start_with?(Dir.pwd + '/') ? f.sub(Dir.pwd + '/', '') : f
+      is_kept = kept[group_idx].include?(fi)
+      marker = is_kept ? " KEEP ".bg(22).fg(255) : "      "
+      label = "#{marker} #{rel}"
+      label = fi == file_idx ? label.u.fg(254) : label.fg(250)
+      lines << label
+    end
+
+    lines << ""
+    # Show neighboring groups for context (compact, no file listing)
+    context_start = [group_idx - 2, 0].max
+    context_end = [group_idx + 5, dupes.size - 1].min
+    (context_start..context_end).each do |gi|
+      next if gi == group_idx
+      g = dupes[gi]
+      m = group_meta[gi]
+      lines << "  [#{gi + 1}] #{format_bytes(m[:size])} x#{g.size} (#{format_bytes(m[:waste])} wasted)".fg(240)
+    end
+
+    @pR.update = true
+    @pR.say(lines.join("\n"))
+
+    chr = getchr
+    case chr
+    when 'q', 'ESC'
+      break
+    when 'j', 'DOWN'
+      group_idx = (group_idx + 1) % dupes.size
+      file_idx = 0
+    when 'k', 'UP'
+      group_idx = (group_idx - 1) % dupes.size
+      file_idx = 0
+    when 'PgDOWN'
+      group_idx = [group_idx + 10, dupes.size - 1].min
+      file_idx = 0
+    when 'PgUP'
+      group_idx = [group_idx - 10, 0].max
+      file_idx = 0
+    when 'RIGHT', 'l', 'ENTER'
+      file_idx = (file_idx + 1) % group.size
+    when 'LEFT', 'h'
+      file_idx = (file_idx - 1) % group.size
+    when 't'
+      # Toggle keep tag on current file
+      if kept[group_idx].include?(file_idx)
+        kept[group_idx].delete(file_idx)
+      else
+        kept[group_idx] << file_idx
+      end
+      file_idx = (file_idx + 1) % group.size if file_idx < group.size - 1
+    when 'd'
+      # Delete all files NOT tagged as keep
+      to_keep = kept[group_idx] || []
+      if to_keep.empty?
+        @pB.say("Tag at least one file to keep first (press t).")
+        next
+      end
+      to_delete = group.each_index.reject { |i| to_keep.include?(i) }
+      if to_delete.empty?
+        @pB.say("All files tagged as keep, nothing to delete.")
+        next
+      end
+      names = to_delete.map { |i| File.basename(group[i]) }
+      @pB.say("Delete #{to_delete.size} files? (y/n)")
+      if getchr == 'y'
+        deleted = 0
+        to_delete.sort.reverse.each do |fi|
+          path = group[fi]
+          begin
+            if @trash
+              timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
+              trash_name = "#{timestamp}_#{File.basename(path)}_#{rand(1000..9999)}"
+              trash_path = File.join(TRASH_DIR, trash_name)
+              command("mv -f #{Shellwords.escape(path)} #{Shellwords.escape(trash_path)}")
+              add_undo_operation({ type: 'delete', trash: true, paths: [{ path: path, trash_name: trash_name }], timestamp: Time.now })
+            else
+              command("rm -rf #{Shellwords.escape(path)}")
+            end
+            deleted += 1
+          rescue
+          end
+        end
+        # Remove deleted files from group (reverse order to preserve indices)
+        to_delete.sort.reverse.each { |fi| group.delete_at(fi) }
+        kept.delete(group_idx)
+        file_idx = 0
+        # Update metadata
+        meta[:waste] = (meta[:size] * (group.size - 1)) rescue 0
+        group_meta[group_idx] = meta
+        wasted_total = group_meta.sum { |m| m[:waste] }
+        # Remove group if only one file remains
+        if group.size <= 1
+          dupes.delete_at(group_idx)
+          group_meta.delete_at(group_idx)
+          # Shift kept indices
+          new_kept = {}
+          kept.each { |k, v| new_kept[k > group_idx ? k - 1 : k] = v if k != group_idx }
+          kept = new_kept
+          if dupes.empty?
+            @pB.say("All duplicates resolved! Freed #{format_bytes(wasted_total)}.")
+            break
+          end
+          group_idx = [group_idx, dupes.size - 1].min
+          wasted_total = group_meta.sum { |m| m[:waste] }
+        end
+        @pB.say("Deleted #{deleted} files.")
+      end
+    end
+  end
+
+  @pR.update = true
+  refresh
+  render
+end
+
+def dupes_progress(msg)
+  @pB.update = true
+  @pB.say(msg)
+  @pB.refresh
+end
+
+def dupes_cancelled?
+  begin
+    $stdin.read_nonblock(1)
+    $stdin.read_nonblock(16) rescue nil
+    true
+  rescue IO::WaitReadable, EOFError
+    false
+  end
+end
+
+def format_bytes(bytes)
+  if bytes >= 1073741824
+    "%.1f GB" % (bytes / 1073741824.0)
+  elsif bytes >= 1048576
+    "%.1f MB" % (bytes / 1048576.0)
+  elsif bytes >= 1024
+    "%.1f KB" % (bytes / 1024.0)
+  else
+    "#{bytes} B"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtfm-filemanager
 version: !ruby/object:Gem::Version
-  version: 8.2.0
+  version: 8.2.1
 platform: ruby
 authors:
 - Geir Isene
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-15 00:00:00.000000000 Z
+date: 2026-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rcurses
@@ -89,6 +89,8 @@ files:
 - docs/remote-browsing.md
 - docs/troubleshooting.md
 - examples/bookmarks.rb
+- examples/diskusage.rb
+- examples/dupes.rb
 - examples/git.rb
 - examples/notes.rb
 - examples/opener.rb