hiiro 0.1.80 → 0.1.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 505147230ad7ebd846dae0bc672cef7e35252e30f134e88ed7595272866b69f4
-  data.tar.gz: 339f416cdac0a03bd469c71266619868b508f1e767d90400f948fa5143604110
+  metadata.gz: 3f87285ddecfdb583f432a5017f6261299b44090af65809fd4a8840f7c497a0a
+  data.tar.gz: 41376a591fe399529e5eb4d2dd33cd01c55eb9f1a9f9f5cc1a56691608e1a631
 SHA512:
-  metadata.gz: 52e86d19f59a78f18eead2ba6ebc8906a3090af015d22044141127c43888a698eac524908f351d49980c5398a4e0d68ef8e3167f0bfe60db01cb47a20e2b1c6d
-  data.tar.gz: 6980d426edd24f936c5e74bf8f081b7d417826e1a16385555dee097c6f6f0d1053595ceaf77d3080d98474e569d20a4fa85111b6b23384c7b10aefb0f238225b
+  metadata.gz: f055d30b6555898fee3011e99ed35085c0989bfb786478815c7e42ece61eba17d7e4c5462b788ca220fa1b06432ebfe17f09cf5d4a84143b8f55b0e0d31da782
+  data.tar.gz: 40f214d34537a625a9ecea49d9ba57d9c96cf2e6a85c586b9854eabc18960d2b14009743458008c4127b822dc5c4e630db293fc55b41b0384586702ff0398029

data/bin/h-buffer

@@ -98,4 +98,25 @@ o.add_subcmd(:clear) { |*args|
   puts "Cleared #{buffers.count} buffers"
 }
 
+o.add_subcmd(:select) do |*args|
+  # Get buffer list with content preview
+  output = `tmux list-buffers -F '\#{buffer_name}: \#{buffer_sample}'`.strip
+
+  if output.empty?
+    STDERR.puts "No buffers found"
+    next
+  end
+
+  lines = output.split("\n").each_with_object({}) do |line, h|
+    buffer_name = line.split(':').first
+    h[line] = buffer_name
+  end
+
+  selected = Hiiro::Sk.map_select(lines)
+
+  if selected
+    print selected
+  end
+end
+
 o.run

data/bin/h-pane

@@ -71,4 +71,25 @@ o.add_subcmd(:history) { |pane_id=nil|
   end
 }
 
+o.add_subcmd(:select) do |*args|
+  # Get all panes with details
+  output = `tmux list-panes -a -F '\#{session_name}:\#{window_index}.\#{pane_index} [\#{pane_current_command}] \#{pane_current_path}'`.strip
+
+  if output.empty?
+    STDERR.puts "No panes found"
+    next
+  end
+
+  lines = output.split("\n").each_with_object({}) do |line, h|
+    pane_id = line.split.first
+    h[line] = pane_id
+  end
+
+  selected = Hiiro::Sk.map_select(lines)
+
+  if selected
+    print selected
+  end
+end
+
 o.run

data/bin/h-pr

@@ -244,6 +244,130 @@ class PRManager
   end
 end
 
+class PinnedPRManager
+  PINNED_FILE = File.join(Dir.home, '.config/hiiro/pinned_prs.yml')
+
+  def initialize
+    ensure_file
+  end
+
+  def ensure_file
+    dir = File.dirname(PINNED_FILE)
+    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+    File.write(PINNED_FILE, [].to_yaml) unless File.exist?(PINNED_FILE)
+  end
+
+  def load_pinned
+    ensure_file
+    YAML.load_file(PINNED_FILE) || []
+  end
+
+  def save_pinned(prs)
+    ensure_file
+    File.write(PINNED_FILE, prs.to_yaml)
+  end
+
+  def pin(pr_info)
+    pinned = load_pinned
+    existing = pinned.find { |p| p['number'] == pr_info['number'] }
+
+    if existing
+      existing.merge!(pr_info)
+      existing['updated_at'] = Time.now.iso8601
+    else
+      pr_info['pinned_at'] = Time.now.iso8601
+      pinned << pr_info
+    end
+
+    save_pinned(pinned)
+    pr_info
+  end
+
+  def unpin(pr_number)
+    pinned = load_pinned
+    removed = pinned.reject! { |p| p['number'].to_s == pr_number.to_s }
+    save_pinned(pinned)
+    removed
+  end
+
+  def pinned?(pr_number)
+    load_pinned.any? { |p| p['number'].to_s == pr_number.to_s }
+  end
+
+  def fetch_pr_info(pr_number)
+    fields = 'number,title,url,headRefName,state,statusCheckRollup'
+    output = `gh pr view #{pr_number} --json #{fields} 2>/dev/null`.strip
+    return nil if output.empty?
+    JSON.parse(output)
+  rescue JSON::ParserError
+    nil
+  end
+
+  def fetch_current_branch_pr
+    fields = 'number,title,url,headRefName,state'
+    output = `gh pr view --json #{fields} 2>/dev/null`.strip
+    return nil if output.empty?
+    JSON.parse(output)
+  rescue JSON::ParserError
+    nil
+  end
+
+  def fetch_my_prs
+    output = `gh pr list --author @me --state open --json number,title,headRefName,url 2>/dev/null`.strip
+    return [] if output.empty?
+    JSON.parse(output) rescue []
+  end
+
+  def refresh_status(pr)
+    info = fetch_pr_info(pr['number'])
+    return pr unless info
+
+    pr['state'] = info['state']
+    pr['title'] = info['title']
+    pr['checks'] = summarize_checks(info['statusCheckRollup'])
+    pr['last_checked'] = Time.now.iso8601
+    pr
+  end
+
+  def summarize_checks(rollup)
+    return nil unless rollup
+
+    contexts = rollup.is_a?(Array) ? rollup : []
+    return nil if contexts.empty?
+
+    total = contexts.length
+    success = contexts.count { |c| c['conclusion'] == 'SUCCESS' }
+    pending = contexts.count { |c| c['status'] == 'PENDING' || c['status'] == 'IN_PROGRESS' }
+    failed = contexts.count { |c| c['conclusion'] == 'FAILURE' || c['conclusion'] == 'ERROR' }
+
+    { 'total' => total, 'success' => success, 'pending' => pending, 'failed' => failed }
+  end
+
+  def display_pinned(pr, idx = nil)
+    num = idx ? "#{(idx + 1).to_s.rjust(3)}." : ""
+    state_icon = case pr['state']
+    when 'MERGED' then '[M]'
+    when 'CLOSED' then '[X]'
+    else '[O]'
+    end
+
+    checks_str = if pr['checks']
+      c = pr['checks']
+      if c['failed'] > 0
+        " [#{c['success']}/#{c['total']} FAIL:#{c['failed']}]"
+      elsif c['pending'] > 0
+        " [#{c['success']}/#{c['total']} pending:#{c['pending']}]"
+      else
+        " [#{c['success']}/#{c['total']}]"
+      end
+    else
+      ""
+    end
+
+    "#{num} #{state_icon} ##{pr['number']} #{pr['title']}#{checks_str}".strip
+  end
+end
+
 WATCH_BLOCK = lambda { |original_pr_number=nil, *args|
   watch = hiiro.get_value(:watch)
   fail_fast = hiiro.get_value(:fail_fast)
@@ -322,6 +446,221 @@ hiiro.add_subcmd(:current) { manager.current }
 hiiro.add_subcmd(:open) { |pr_number=nil| manager.open(pr_number) }
 hiiro.add_subcmd(:view) { |pr_number=nil| manager.view(pr_number) }
 
+hiiro.add_subcmd(:select) do |*args|
+  # Get my open PRs
+  output = `gh pr list --author @me --state open --json number,title,headRefName 2>/dev/null`.strip
+
+  if output.empty?
+    STDERR.puts "No open PRs found"
+    next
+  end
+
+  prs = JSON.parse(output) rescue []
+  if prs.empty?
+    STDERR.puts "No open PRs found"
+    next
+  end
+
+  lines = prs.each_with_object({}) do |pr, h|
+    display = "##{pr['number']} [#{pr['headRefName']}] #{pr['title']}"
+    h[display] = pr['number'].to_s
+  end
+
+  selected = Hiiro::Sk.map_select(lines)
+
+  if selected
+    print selected
+  end
+end
+
+# === PR Pinning ===
+
+pinned_manager = PinnedPRManager.new
+
+hiiro.add_subcmd(:pin) do |ref = nil, *args|
+  pr_info = nil
+
+  case ref
+  when '-', nil
+    if ref == '-'
+      # Pin current branch's PR
+      pr_info = pinned_manager.fetch_current_branch_pr
+      unless pr_info
+        puts "No PR found for current branch"
+        next
+      end
+    else
+      # Select from my PRs
+      my_prs = pinned_manager.fetch_my_prs
+      if my_prs.empty?
+        puts "No open PRs found"
+        next
+      end
+
+      lines = my_prs.each_with_object({}) do |pr, h|
+        display = "##{pr['number']} [#{pr['headRefName']}] #{pr['title']}"
+        h[display] = pr
+      end
+
+      pr_info = Hiiro::Sk.map_select(lines)
+      unless pr_info
+        puts "No PR selected"
+        next
+      end
+    end
+  when /^\d+$/
+    # Pin by PR number
+    pr_info = pinned_manager.fetch_pr_info(ref)
+    unless pr_info
+      puts "PR ##{ref} not found"
+      next
+    end
+  else
+    puts "Usage: h pr pin [-|PR_NUMBER]"
+    puts "  -       Pin current branch's PR"
+    puts "  <num>   Pin PR by number"
+    puts "  (none)  Select from your open PRs"
+    next
+  end
+
+  pinned_manager.pin(pr_info)
+  puts "Pinned PR ##{pr_info['number']}: #{pr_info['title']}"
+end
+
+hiiro.add_subcmd(:unpin) do |ref = nil, *args|
+  pinned = pinned_manager.load_pinned
+
+  if pinned.empty?
+    puts "No pinned PRs"
+    next
+  end
+
+  pr_number = nil
+
+  if ref.nil?
+    # Select from pinned PRs
+    lines = pinned.each_with_index.each_with_object({}) do |(pr, idx), h|
+      h[pinned_manager.display_pinned(pr, idx)] = pr['number'].to_s
+    end
+
+    pr_number = Hiiro::Sk.map_select(lines)
+    unless pr_number
+      puts "No PR selected"
+      next
+    end
+  elsif ref =~ /^\d+$/
+    pr_number = ref
+  else
+    puts "Usage: h pr unpin [PR_NUMBER]"
+    next
+  end
+
+  if pinned_manager.unpin(pr_number)
+    puts "Unpinned PR ##{pr_number}"
+  else
+    puts "PR ##{pr_number} was not pinned"
+  end
+end
+
+hiiro.add_subcmd(:pinned) do |*args|
+  pinned = pinned_manager.load_pinned
+
+  if pinned.empty?
+    puts "No pinned PRs"
+    next
+  end
+
+  puts "Pinned PRs:"
+  puts
+
+  pinned.each_with_index do |pr, idx|
+    puts pinned_manager.display_pinned(pr, idx)
+  end
+end
+
+hiiro.add_subcmd(:status) do |*args|
+  pinned = pinned_manager.load_pinned
+
+  if pinned.empty?
+    puts "No pinned PRs"
+    next
+  end
+
+  puts "Refreshing status for #{pinned.length} pinned PR(s)..."
+  puts
+
+  pinned.each_with_index do |pr, idx|
+    pinned_manager.refresh_status(pr)
+    puts pinned_manager.display_pinned(pr, idx)
+  end
+
+  pinned_manager.save_pinned(pinned)
+  puts
+  puts "Status updated at #{Time.now.strftime('%H:%M:%S')}"
+end
+
+hiiro.add_subcmd(:'suggest-unpin') do |*args|
+  pinned = pinned_manager.load_pinned
+
+  if pinned.empty?
+    puts "No pinned PRs"
+    next
+  end
+
+  # Refresh all statuses first
+  pinned.each { |pr| pinned_manager.refresh_status(pr) }
+  pinned_manager.save_pinned(pinned)
+
+  merged = pinned.select { |pr| pr['state'] == 'MERGED' }
+  closed = pinned.select { |pr| pr['state'] == 'CLOSED' }
+
+  if merged.empty? && closed.empty?
+    puts "No merged or closed PRs to unpin"
+    next
+  end
+
+  puts "PRs that can be unpinned:"
+  puts
+
+  (merged + closed).each_with_index do |pr, idx|
+    puts pinned_manager.display_pinned(pr, idx)
+  end
+
+  puts
+  puts "Run 'h pr auto-unpin' to unpin all merged/closed PRs"
+end
+
+hiiro.add_subcmd(:'auto-unpin') do |*args|
+  pinned = pinned_manager.load_pinned
+
+  if pinned.empty?
+    puts "No pinned PRs"
+    next
+  end
+
+  # Refresh all statuses first
+  pinned.each { |pr| pinned_manager.refresh_status(pr) }
+
+  merged_or_closed = pinned.select { |pr| pr['state'] == 'MERGED' || pr['state'] == 'CLOSED' }
+
+  if merged_or_closed.empty?
+    puts "No merged or closed PRs to unpin"
+    pinned_manager.save_pinned(pinned)
+    next
+  end
+
+  puts "Unpinning #{merged_or_closed.length} merged/closed PR(s):"
+  puts
+
+  merged_or_closed.each do |pr|
+    puts "  ##{pr['number']}: #{pr['title']} [#{pr['state']}]"
+    pinned_manager.unpin(pr['number'])
+  end
+
+  puts
+  puts "Done. #{pinned_manager.load_pinned.length} PR(s) still pinned."
+end
+
 # hiiro.add_default { manager.help }
 
 hiiro.run

data/bin/h-project

@@ -136,6 +136,32 @@ o.add_subcmd(:edit) { |*args|
   exec(editor, projects_file)
 }
 
+# === SELECT PROJECT ===
+
+o.add_subcmd(:select) { |*args|
+  dirs = project_dirs
+  conf = projects_from_config
+
+  all_projects = dirs.merge(conf)
+
+  if all_projects.empty?
+    STDERR.puts "No projects found"
+    next
+  end
+
+  lines = all_projects.each_with_object({}) do |(name, path), h|
+    source = conf.key?(name) ? '[config]' : '[dir]'
+    display = format("%-15s %s  %s", name, source, path)
+    h[display] = path
+  end
+
+  selected = Hiiro::Sk.map_select(lines)
+
+  if selected
+    print selected
+  end
+}
+
 # === HELP ===
 
 o.add_subcmd(:help) { |*args|

data/bin/h-remind

@@ -0,0 +1,614 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'fileutils'
+require 'time'
+require 'tempfile'
+require 'hiiro'
+
+class ReminderManager
+  REMINDERS_FILE = File.join(Dir.home, '.config/hiiro/reminders.yml')
+  REMINDER_TEMPLATE = {
+    'message' => '',
+    'interval' => '1h',
+    'sound' => nil,
+    'enabled' => true,
+    'once' => false,
+    'trigger_at' => nil,
+    'last_triggered' => nil,
+    'created_at' => Time.now.iso8601,
+  }
+
+  class Reminder
+    attr_accessor :message, :interval, :sound, :enabled, :once, :trigger_at, :last_triggered, :created_at
+
+    def initialize(message:, interval: '1h', sound: nil, enabled: true, once: false, trigger_at: nil, last_triggered: nil, created_at: Time.now.iso8601)
+      @message = message
+      @interval = interval
+      @sound = sound
+      @enabled = enabled
+      @once = once
+      @trigger_at = trigger_at
+      @last_triggered = last_triggered
+      @created_at = created_at
+    end
+
+    def self.from_hash(hash)
+      new(
+        message: hash['message'],
+        interval: hash['interval'] || '1h',
+        sound: hash['sound'],
+        enabled: hash['enabled'] != false,
+        once: hash['once'] == true,
+        trigger_at: hash['trigger_at'],
+        last_triggered: hash['last_triggered'],
+        created_at: hash['created_at'] || Time.now.iso8601
+      )
+    end
+
+    def to_h
+      {
+        'message' => @message,
+        'interval' => @interval,
+        'sound' => @sound,
+        'enabled' => @enabled,
+        'once' => @once,
+        'trigger_at' => @trigger_at,
+        'last_triggered' => @last_triggered,
+        'created_at' => @created_at
+      }
+    end
+
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    def interval_seconds
+      parse_interval(@interval)
+    end
+
+    def parse_interval(str)
+      return 3600 unless str # default 1 hour
+
+      match = str.to_s.match(/^(\d+)([smhdw])$/i)
+      return 3600 unless match
+
+      num = match[1].to_i
+      unit = match[2].downcase
+
+      case unit
+      when 's' then num
+      when 'm' then num * 60
+      when 'h' then num * 3600
+      when 'd' then num * 86400
+      when 'w' then num * 604800
+      else 3600
+      end
+    end
+
+    def one_time?
+      @once == true
+    end
+
+    def should_trigger?
+      return false unless @enabled
+
+      if one_time?
+        # One-time reminder: check if trigger_at time has passed
+        return false if @last_triggered # already triggered
+        return false unless @trigger_at
+
+        trigger_time = Time.parse(@trigger_at) rescue nil
+        return false unless trigger_time
+
+        Time.now >= trigger_time
+      else
+        # Recurring reminder: check interval since last trigger
+        return true if @last_triggered.nil?
+
+        last_time = Time.parse(@last_triggered) rescue Time.at(0)
+        Time.now - last_time >= interval_seconds
+      end
+    end
+
+    def trigger!
+      @last_triggered = Time.now.iso8601
+      # For one-time reminders, disable after triggering
+      @enabled = false if one_time?
+    end
+
+    def display_string(index = nil)
+      num = index ? "#{(index + 1).to_s.rjust(3)}." : ""
+      status = @enabled ? "[ON]" : "[OFF]"
+      sound_str = @sound ? " (#{@sound})" : ""
+
+      if one_time?
+        if @trigger_at
+          trigger_time = Time.parse(@trigger_at) rescue nil
+          time_str = trigger_time ? trigger_time.strftime('%Y-%m-%d %H:%M') : @trigger_at
+          "#{num} #{status} [ONCE @ #{time_str}] #{@message}#{sound_str}".strip
+        else
+          "#{num} #{status} [ONCE] #{@message}#{sound_str}".strip
+        end
+      else
+        "#{num} #{status} [#{@interval}] #{@message}#{sound_str}".strip
+      end
+    end
+  end
+
+  # Parse time argument - returns [is_once, trigger_at, interval]
+  def self.parse_time_arg(time_str)
+    return [false, nil, '1h'] if time_str.nil?
+
+    # Check for absolute time format: YYYYmmddHHMM
+    if time_str =~ /^(\d{12})$/
+      year = $1[0..3].to_i
+      month = $1[4..5].to_i
+      day = $1[6..7].to_i
+      hour = $1[8..9].to_i
+      min = $1[10..11].to_i
+      trigger_at = Time.new(year, month, day, hour, min).iso8601
+      return [true, trigger_at, nil]
+    end
+
+    # Check for relative interval format: 15m, 2h, etc.
+    if time_str =~ /^(\d+)([smhdw])$/i
+      num = $1.to_i
+      unit = $2.downcase
+      seconds = case unit
+      when 's' then num
+      when 'm' then num * 60
+      when 'h' then num * 3600
+      when 'd' then num * 86400
+      when 'w' then num * 604800
+      else num * 60
+      end
+
+      # This is a one-time reminder at a relative time
+      trigger_at = (Time.now + seconds).iso8601
+      return [true, trigger_at, time_str]
+    end
+
+    # Default: treat as recurring interval
+    [false, nil, time_str]
+  end
+
+  attr_reader :reminders_file
+
+  def initialize(reminders_file = REMINDERS_FILE)
+    @reminders_file = reminders_file
+  end
+
+  def ensure_reminders_file
+    dir = File.dirname(@reminders_file)
+    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+    File.write(@reminders_file, [].to_yaml) unless File.exist?(@reminders_file)
+  end
+
+  def load_reminders
+    ensure_reminders_file
+    data = YAML.load_file(@reminders_file) || []
+    data.map { |hash| Reminder.from_hash(hash) }
+  end
+
+  def save_reminders(reminders)
+    ensure_reminders_file
+    data = reminders.map(&:to_h)
+    File.write(@reminders_file, data.to_yaml)
+  end
+
+  def load_reminder_hash(reminders = nil)
+    reminders ||= load_reminders
+    reminders.each_with_index.each_with_object({}) do |(reminder, idx), h|
+      h[reminder.display_string(idx)] = reminder
+    end
+  end
+
+  def edit_reminders(reminders = nil)
+    reminders_array = if reminders.nil?
+      [REMINDER_TEMPLATE]
+    elsif reminders.is_a?(Array)
+      reminders.map { |r| r.is_a?(Reminder) ? r.to_h : r }
+    else
+      [reminders.is_a?(Reminder) ? reminders.to_h : reminders]
+    end
+
+    tmpfile = Tempfile.new(['reminder-edit-', '.yml'])
+    tmpfile.write(reminders_array.to_yaml)
+    tmpfile.close
+
+    system(ENV['EDITOR'] || 'vim', tmpfile.path)
+
+    updated_data = YAML.load_file(tmpfile.path)
+    tmpfile.unlink
+
+    updated_array = updated_data.is_a?(Array) ? updated_data : [updated_data]
+    updated_array.map { |hash| Reminder.from_hash(hash) }
+  end
+
+  def find_reminder_by_ref(ref, reminders)
+    if ref =~ /^\d+$/
+      idx = ref.to_i - 1
+      return [idx, reminders[idx]] if idx >= 0 && idx < reminders.length
+    end
+    [nil, nil]
+  end
+end
+
+rm = ReminderManager.new
+o = Hiiro.init(*ARGV, plugins: [Pins], reminders_file: rm.reminders_file)
+
+o.add_subcmd(:add) do |message = nil, time_arg = nil, sound = nil, *args|
+  reminders = rm.load_reminders
+
+  if message.nil?
+    new_reminders = rm.edit_reminders
+
+    reminders.concat(new_reminders)
+    rm.save_reminders(reminders)
+
+    if new_reminders.length == 1
+      puts "Saved reminder ##{reminders.length}: #{new_reminders.first.message}"
+    else
+      puts "Saved #{new_reminders.length} reminders (#{reminders.length - new_reminders.length + 1}-#{reminders.length})"
+    end
+    next
+  end
+
+  is_once, trigger_at, interval = ReminderManager.parse_time_arg(time_arg)
+
+  new_reminder = ReminderManager::Reminder.new(
+    message: message,
+    interval: interval,
+    sound: sound,
+    once: is_once,
+    trigger_at: trigger_at,
+    created_at: Time.now.iso8601
+  )
+
+  reminders << new_reminder
+  rm.save_reminders(reminders)
+
+  if is_once
+    trigger_time = Time.parse(trigger_at)
+    puts "Saved one-time reminder ##{reminders.length}: #{message} (at #{trigger_time.strftime('%Y-%m-%d %H:%M')})"
+  else
+    puts "Saved recurring reminder ##{reminders.length}: #{message} (every #{interval || '1h'})"
+  end
+end
+
+o.add_subcmd(:once) do |message = nil, time_arg = nil, sound = nil, *args|
+  reminders = rm.load_reminders
+
+  if message.nil?
+    puts "Usage: h remind once 'message' <time> [sound]"
+    puts "  time: 15m, 2h, 1d OR YYYYmmddHHMM"
+    next
+  end
+
+  time_arg ||= '1h'
+  is_once, trigger_at, interval = ReminderManager.parse_time_arg(time_arg)
+
+  # Force one-time even if parse didn't detect it
+  unless trigger_at
+    seconds = ReminderManager::Reminder.new(message: '').parse_interval(time_arg)
+    trigger_at = (Time.now + seconds).iso8601
+  end
+
+  new_reminder = ReminderManager::Reminder.new(
+    message: message,
+    interval: interval,
+    sound: sound,
+    once: true,
+    trigger_at: trigger_at,
+    created_at: Time.now.iso8601
+  )
+
+  reminders << new_reminder
+  rm.save_reminders(reminders)
+
+  trigger_time = Time.parse(trigger_at)
+  puts "Saved one-time reminder ##{reminders.length}: #{message} (at #{trigger_time.strftime('%Y-%m-%d %H:%M')})"
+end
+
+o.add_subcmd(:every) do |message = nil, interval = nil, sound = nil, *args|
+  reminders = rm.load_reminders
+
+  if message.nil?
+    puts "Usage: h remind every 'message' <interval> [sound]"
+    puts "  interval: 15m, 2h, 1d, 1w"
+    next
+  end
+
+  new_reminder = ReminderManager::Reminder.new(
+    message: message,
+    interval: interval || '1h',
+    sound: sound,
+    once: false,
+    created_at: Time.now.iso8601
+  )
+
+  reminders << new_reminder
+  rm.save_reminders(reminders)
+
+  puts "Saved recurring reminder ##{reminders.length}: #{message} (every #{interval || '1h'})"
+end
+
+o.add_subcmd(:ls) do |*args|
+  reminders = rm.load_reminders
+  if reminders.empty?
+    puts "No reminders saved."
+  else
+    reminders.each_with_index do |reminder, idx|
+      puts reminder.display_string(idx)
+    end
+  end
+end
+
+o.add_subcmd(:list) do |*args|
+  o.run_subcmd(:ls, *args)
+end
+
+o.add_subcmd(:remove) do |ref = nil, *args|
+  reminders = rm.load_reminders
+
+  if reminders.empty?
+    puts "No reminders to remove."
+    next
+  end
+
+  idx = nil
+  if ref.nil?
+    lines = rm.load_reminder_hash(reminders)
+
+    require 'open3'
+    selected, status = Open3.capture2('sk', stdin_data: lines.keys.join("\n"))
+
+    if status.success? && !selected.strip.empty?
+      reminder = lines[selected.strip]
+      idx = reminders.index(reminder)
+    end
+  else
+    idx, _ = rm.find_reminder_by_ref(ref, reminders)
+  end
+
+  if idx.nil?
+    puts "Reminder not found"
+    next
+  end
+
+  removed = reminders.delete_at(idx)
+  rm.save_reminders(reminders)
+  puts "Removed reminder: #{removed.message}"
+end
+
+o.add_subcmd(:pause) do |ref = nil, *args|
+  reminders = rm.load_reminders
+
+  if reminders.empty?
+    puts "No reminders to pause."
+    next
+  end
+
+  idx = nil
+  if ref.nil?
+    enabled_reminders = reminders.select(&:enabled)
+    if enabled_reminders.empty?
+      puts "No enabled reminders to pause."
+      next
+    end
+
+    lines = enabled_reminders.each_with_index.each_with_object({}) do |(r, i), h|
+      actual_idx = reminders.index(r)
+      h[r.display_string(actual_idx)] = actual_idx
+    end
+
+    require 'open3'
+    selected, status = Open3.capture2('sk', stdin_data: lines.keys.join("\n"))
+
+    if status.success? && !selected.strip.empty?
+      idx = lines[selected.strip]
+    end
+  else
+    idx, _ = rm.find_reminder_by_ref(ref, reminders)
+  end
+
+  if idx.nil?
+    puts "Reminder not found"
+    next
+  end
+
+  reminders[idx].enabled = false
+  rm.save_reminders(reminders)
+  puts "Paused reminder: #{reminders[idx].message}"
+end
+
+o.add_subcmd(:resume) do |ref = nil, *args|
+  reminders = rm.load_reminders
+
+  if reminders.empty?
+    puts "No reminders to resume."
+    next
+  end
+
+  idx = nil
+  if ref.nil?
+    disabled_reminders = reminders.reject(&:enabled)
+    if disabled_reminders.empty?
+      puts "No paused reminders to resume."
+      next
+    end
+
+    lines = disabled_reminders.each_with_index.each_with_object({}) do |(r, i), h|
+      actual_idx = reminders.index(r)
+      h[r.display_string(actual_idx)] = actual_idx
+    end
+
+    require 'open3'
+    selected, status = Open3.capture2('sk', stdin_data: lines.keys.join("\n"))
+
+    if status.success? && !selected.strip.empty?
+      idx = lines[selected.strip]
+    end
+  else
+    idx, _ = rm.find_reminder_by_ref(ref, reminders)
+  end
+
+  if idx.nil?
+    puts "Reminder not found"
+    next
+  end
+
+  reminders[idx].enabled = true
+  rm.save_reminders(reminders)
+  puts "Resumed reminder: #{reminders[idx].message}"
+end
+
+o.add_subcmd(:check) do |*args|
+  reminders = rm.load_reminders
+  triggered_count = 0
+  verbose = args.include?('-v') || args.include?('--verbose')
+
+  reminders.each do |reminder|
+    next unless reminder.should_trigger?
+
+    # Build notification options
+    notification_args = ['-m', reminder.message, '-t', 'Reminder']
+    notification_args += ['-s', reminder.sound] if reminder.sound
+
+    # Use Hiiro::Notification to show the notification
+    notif_hiiro = Hiiro.init(*notification_args)
+    Hiiro::Notification.show(notif_hiiro)
+
+    reminder.trigger!
+    triggered_count += 1
+
+    if verbose
+      if reminder.one_time?
+        puts "Triggered (one-time): #{reminder.message}"
+      else
+        puts "Triggered: #{reminder.message}"
+      end
+    end
+  end
+
+  rm.save_reminders(reminders)
+
+  if verbose
+    enabled_count = reminders.count(&:enabled)
+    one_time_done = reminders.count { |r| r.one_time? && !r.enabled }
+    puts "Checked #{enabled_count} enabled reminders, triggered #{triggered_count}"
+    puts "#{one_time_done} completed one-time reminder(s) (use 'h remind clean' to remove)" if one_time_done > 0
+  end
+end
+
+o.add_subcmd(:clean) do |*args|
+  reminders = rm.load_reminders
+  before_count = reminders.length
+
+  # Remove disabled one-time reminders (already triggered)
+  reminders.reject! { |r| r.one_time? && !r.enabled }
+
+  after_count = reminders.length
+  removed = before_count - after_count
+
+  rm.save_reminders(reminders)
+
+  if removed > 0
+    puts "Removed #{removed} completed one-time reminder(s)"
+  else
+    puts "No completed one-time reminders to clean up"
+  end
+end
+
+o.add_subcmd(:howto) do |*args|
+  puts <<~HOWTO
+    h remind - Reminder notification system
+
+    SETUP FOR CRON:
+    ===============
+    Add the following line to your crontab (run 'crontab -e'):
+
+      * * * * * #{File.expand_path('~/.rbenv/shims/h')} remind check
+
+    Or if you want verbose logging:
+
+      * * * * * #{File.expand_path('~/.rbenv/shims/h')} remind check -v >> ~/.config/hiiro/remind.log 2>&1
+
+    USAGE:
+    ======
+    # One-time reminders (triggers once, then disables)
+    h remind add 'Read the news' 15m             # Remind in 15 minutes
+    h remind add 'Meeting' 202602131430          # Remind at specific time (YYYYmmddHHMM)
+    h remind once 'Call mom' 2h                  # Explicit one-time in 2 hours
+
+    # Recurring reminders
+    h remind every 'Take a break' 30m            # Remind every 30 minutes
+    h remind every 'Stand up' 1h basso           # Remind hourly with 'basso' sound
+
+    # Editor mode
+    h remind add                                 # Open editor to add reminder(s)
+
+    # Management
+    h remind ls                                  # List all reminders
+    h remind remove                              # Select and remove a reminder
+    h remind remove 2                            # Remove reminder #2
+    h remind clean                               # Remove completed one-time reminders
+
+    h remind pause                               # Select and pause a reminder
+    h remind pause 1                             # Pause reminder #1
+    h remind resume                              # Select and resume a reminder
+    h remind resume 1                            # Resume reminder #1
+
+    h remind check                               # Check and trigger due reminders
+    h remind check -v                            # Verbose mode
+
+    TIME FORMATS:
+    =============
+    Relative (one-time): 15m, 2h, 1d  - triggers once after delay
+    Absolute (one-time): YYYYmmddHHMM - triggers at specific date/time
+                         e.g., 202602131430 = Feb 13, 2026 at 14:30
+
+    Use 'h remind every' to create recurring reminders with intervals.
+
+    INTERVAL FORMAT (for recurring):
+    =================================
+    s = seconds (e.g., 30s)
+    m = minutes (e.g., 10m)
+    h = hours   (e.g., 2h)
+    d = days    (e.g., 1d)
+    w = weeks   (e.g., 1w)
+
+    SOUNDS:
+    =======
+    Custom sounds can be placed in: ~/.config/hiiro/sounds/
+    Use the filename (without extension) as the sound name.
+
+    CONFIG FILE:
+    ============
+    Reminders are stored in: #{ReminderManager::REMINDERS_FILE}
+  HOWTO
+end
+
+o.add_subcmd(:path) do |*args|
+  print rm.reminders_file
+end
+
+o.add_subcmd(:editall) do |*args|
+  reminders_before = rm.load_reminders
+  system(ENV['EDITOR'] || 'vim', rm.reminders_file)
+
+  begin
+    rm.load_reminders
+  rescue => e
+    puts "ERROR: Unable to read updated file...reverting."
+    rm.save_reminders(reminders_before)
+  end
+end
+
+begin
+  o.run
+rescue => e
+  require 'pry'
+  binding.pry
+end

data/bin/h-sha

@@ -2,9 +2,56 @@
 
 require 'hiiro'
 
-BASE_DIR = File.join(Dir.home, 'work/carrot')
+Hiiro.init(*ARGV, plugins: [Pins]) { |hiiro|
 
-Hiiro.init(*ARGV, plugins: [Tmux, Pins, Project]) { |hiiro|
+  hiiro.add_subcmd(:select) do |*args|
+    # Get git log with format: sha - subject
+    log_output = `git log --oneline -100 #{args.join(' ')}`.strip
+
+    if log_output.empty?
+      STDERR.puts "No commits found"
+      next
+    end
+
+    lines = log_output.split("\n").each_with_object({}) do |line, h|
+      sha = line.split.first
+      h[line] = sha
+    end
+
+    selected = Hiiro::Sk.map_select(lines)
+
+    if selected
+      print selected
+    end
+  end
+
+  hiiro.add_subcmd(:ls) do |*args|
+    system('git', 'log', '--oneline', *args)
+  end
+
+  hiiro.add_subcmd(:show) do |sha = nil, *args|
+    if sha.nil?
+      sha = `h sha select`.strip
+      next if sha.empty?
+    end
+
+    system('git', 'show', sha, *args)
+  end
+
+  hiiro.add_subcmd(:copy) do |sha = nil, *args|
+    if sha.nil?
+      sha = `h sha select`.strip
+      next if sha.empty?
+    end
+
+    require 'open3'
+    Open3.popen3('pbcopy') do |stdin, stdout, stderr, wait_thr|
+      stdin.write(sha)
+      stdin.close
+      wait_thr.value
+    end
+    puts "Copied #{sha} to clipboard"
+  end
 
 }.run
 

data/bin/h-window

@@ -68,4 +68,25 @@ o.add_subcmd(:history) { |window_id=nil|
   end
 }
 
+o.add_subcmd(:select) do |*args|
+  # Get all windows with details
+  output = `tmux list-windows -a -F '\#{session_name}:\#{window_index} \#{window_name} [\#{window_panes} panes]'`.strip
+
+  if output.empty?
+    STDERR.puts "No windows found"
+    next
+  end
+
+  lines = output.split("\n").each_with_object({}) do |line, h|
+    window_id = line.split.first
+    h[line] = window_id
+  end
+
+  selected = Hiiro::Sk.map_select(lines)
+
+  if selected
+    print selected
+  end
+end
+
 o.run

data/bin/h-wtree

@@ -12,5 +12,27 @@ Hiiro.run(*ARGV) do |h|
   h.add_subcmd(:remove)  { |*args| system('git', 'worktree', 'remove', *args) }
   h.add_subcmd(:repair)  { |*args| system('git', 'worktree', 'repair', *args) }
   h.add_subcmd(:unlock)  { |*args| system('git', 'worktree', 'unlock', *args) }
+
+  h.add_subcmd(:select) do |*args|
+    # Get worktree list
+    output = `git worktree list`.strip
+
+    if output.empty?
+      STDERR.puts "No worktrees found"
+      next
+    end
+
+    lines = output.split("\n").each_with_object({}) do |line, hash|
+      # Format: /path/to/worktree  sha [branch]
+      path = line.split.first
+      hash[line] = path
+    end
+
+    selected = Hiiro::Sk.map_select(lines)
+
+    if selected
+      print selected
+    end
+  end
 end
 

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.80"
+  VERSION = "0.1.81"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.80
+  version: 0.1.81
 platform: ruby
 authors:
 - Joshua Toyota
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -82,6 +81,7 @@ files:
 - bin/h-plugin
 - bin/h-pr
 - bin/h-project
+- bin/h-remind
 - bin/h-serve
 - bin/h-session
 - bin/h-sha
@@ -134,7 +134,6 @@ metadata:
   homepage_uri: https://github.com/unixsuperhero/hiiro
   source_code_uri: https://github.com/unixsuperhero/hiiro
   changelog_uri: https://github.com/unixsuperhero/hiiro/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -149,8 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A lightweight CLI framework for Ruby
 test_files: []