hiiro 0.1.85 → 0.1.86

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 711ddf464139bf62e19c852705b3bc4663f563d5513ad5d254d82225ed18622a
-  data.tar.gz: 407f809d3cd61e38badea49d6a0aa07da9e37bea82a2b51a8490fe38c380b8b4
+  metadata.gz: 2da3861933a1b2b03e5ff7cd9fa87d700e7f3f1ed8e6eb62463ec93c783e2a86
+  data.tar.gz: 9c5957829cae479530f68cccae440bc683285a93e1695db75c4a44dfa1a02503
 SHA512:
-  metadata.gz: 6c3d6e03f0d0fecc10ee37035c445a4f5cd127c8c657e741a269a1901ab947aee813a6d71eb73e164cef6232fe5fd939362c7c8d503c1db30adbcd1834265367
-  data.tar.gz: c5b40ea4b56ad100bca2d0670d3338187ff1effcde9c24b63695652b46056e5704366f5fb16364fa01906e945412e478bd35fd69dd0eec6988ac95c067e0119f
+  metadata.gz: 6c0c41355a0c33056574f1e4c61d937087e7b8fedb1db2fe864f41f571264c44c8c7c46af14b4e238d17f202f061f599fb982fa7fdcfddc7829051802462e7f8
+  data.tar.gz: 07a5888842492bf0aa9b9ed5444b9f9b12bb15ea14615b70eaeb44b4c0e41d9319e1ffdbab80eba422108a91cb68dfb5c0c20edc9f76500364eaf67ee5671d25

data/bin/h-branch

@@ -14,6 +14,18 @@ class BranchManager
     @hiiro = hiiro
   end
 
+  def help
+    puts "Usage: h branch <subcommand> [args]"
+    puts
+    puts "Subcommands:"
+    puts "  save                  Record current branch for this task"
+    puts "  history               List branch history (oldest to newest)"
+    puts "  history --worktree=X  Filter by worktree"
+    puts "  history --task=X      Filter by task"
+    puts "  history --session=X   Filter by tmux session"
+    puts "  current               Show current branch info"
+  end
+
   def save
     branch_name = current_branch
     unless branch_name
@@ -50,6 +62,35 @@ class BranchManager
     true
   end
 
+  def history(args = [])
+    filters = parse_filters(args)
+    data = load_data
+    branches = data['branches'] || []
+
+    if branches.empty?
+      puts "No branches recorded."
+      puts "Use 'h branch save' to record the current branch."
+      return
+    end
+
+    # Apply filters
+    branches = filter_entries(branches, filters)
+
+    if branches.empty?
+      puts "No branches match the given filters."
+      return
+    end
+
+    # Sort by created_at (oldest first)
+    branches = branches.sort_by { |b| b['created_at'] || '' }
+
+    puts "Branch history (oldest to newest):"
+    puts
+    branches.each_with_index do |branch, idx|
+      puts format_entry(branch, idx + 1)
+    end
+  end
+
   def current
     branch_name = current_branch
     unless branch_name
@@ -91,6 +132,48 @@ class BranchManager
     }
   end
 
+  def parse_filters(args)
+    filters = {}
+    args.each do |arg|
+      case arg
+      when /^--worktree=(.+)$/
+        filters[:worktree] = $1
+      when /^--task=(.+)$/
+        filters[:task] = $1
+      when /^--session=(.+)$/
+        filters[:session] = $1
+      when /^-w(.+)$/
+        filters[:worktree] = $1
+      when /^-t(.+)$/
+        filters[:task] = $1
+      when /^-s(.+)$/
+        filters[:session] = $1
+      end
+    end
+    filters
+  end
+
+  def filter_entries(entries, filters)
+    entries.select do |entry|
+      next false if filters[:worktree] && !entry['worktree']&.include?(filters[:worktree])
+      next false if filters[:task] && !entry['task']&.include?(filters[:task])
+      next false if filters[:session] && entry.dig('tmux', 'session') != filters[:session]
+      true
+    end
+  end
+
+  def format_entry(entry, num)
+    lines = []
+    lines << "#{num}. #{entry['name']}"
+    lines << "   Task: #{entry['task'] || '(none)'}"
+    lines << "   Worktree: #{entry['worktree'] || '(none)'}"
+    if entry['tmux']
+      lines << "   Tmux: #{entry['tmux']['session']}/#{entry['tmux']['window']}"
+    end
+    lines << "   Created: #{entry['created_at']}"
+    lines.join("\n")
+  end
+
   def show_entry(entry)
     puts "  Branch: #{entry[:name]}"
     puts "  Task: #{entry[:task] || '(none)'}"
@@ -122,8 +205,7 @@ manager = BranchManager.new(hiiro)
 hiiro.add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }
 hiiro.add_subcmd(:save) { manager.save }
 hiiro.add_subcmd(:history) { |*args| manager.history(args) }
-hiiro.add_subcmd(:current) { print `git branch --show-current` }
-hiiro.add_subcmd(:info) { manager.current }
+hiiro.add_subcmd(:current) { manager.current }
 hiiro.add_subcmd(:select) do |*args|
   branches = hiiro.git.branches(sort_by: 'authordate', ignore_case: true)
 
@@ -259,36 +341,6 @@ hiiro.add_subcmd(:diff) { |*args|
   system('git', 'log', '--oneline', '--decorate', range)
 }
 
-hiiro.add_subcmd(:changed) { |*args|
-  show_all = args.delete('-a') || args.delete('--all')
-  upstream = args.first
-
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
-  }
-
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
-
-  forkpoint = `git merge-base --fork-point #{upstream} HEAD 2>/dev/null`.strip
-  if forkpoint.empty?
-    forkpoint = `git merge-base #{upstream} HEAD 2>/dev/null`.strip
-  end
-
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
-
-  if show_all
-    system('git', 'diff', '--name-only', "#{forkpoint}...HEAD")
-  else
-    system('git', 'diff', '--name-only', '--relative', "#{forkpoint}...HEAD")
-  end
-}
-
 hiiro.add_subcmd(:ahead) { |*args|
   case args.length
   when 0
@@ -323,115 +375,6 @@ hiiro.add_subcmd(:behind) { |*args|
   puts "#{branch} is #{count} commit(s) behind #{behind_of}"
 }
 
-hiiro.add_subcmd(:log) { |upstream = nil|
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
-  }
-
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
-
-  forkpoint = `git merge-base --fork-point #{upstream} HEAD 2>/dev/null`.strip
-  if forkpoint.empty?
-    forkpoint = `git merge-base #{upstream} HEAD 2>/dev/null`.strip
-  end
-
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
-
-  system('git', 'log', '--oneline', '--decorate', "#{forkpoint}..HEAD")
-}
-
-hiiro.add_subcmd(:forkpoint) { |upstream = nil, branch = nil|
-  branch ||= 'HEAD'
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
-  }
-
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
-
-  forkpoint = `git merge-base --fork-point #{upstream} #{branch} 2>/dev/null`.strip
-
-  if forkpoint.empty?
-    # Fallback to regular merge-base if fork-point fails
-    forkpoint = `git merge-base #{upstream} #{branch} 2>/dev/null`.strip
-  end
-
-  if forkpoint.empty?
-    puts "Could not find fork point between #{upstream} and #{branch}"
-  else
-    puts forkpoint
-  end
-}
-
-hiiro.add_subcmd(:changed) { |*args|
-  show_all = args.delete('-a') || args.delete('--all')
-  upstream = args.first
-
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
-  }
-
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
-
-  forkpoint = `git merge-base --fork-point #{upstream} HEAD 2>/dev/null`.strip
-  if forkpoint.empty?
-    forkpoint = `git merge-base #{upstream} HEAD 2>/dev/null`.strip
-  end
-
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
-
-  if show_all
-    system('git', 'diff', '--name-only', "#{forkpoint}...HEAD")
-  else
-    system('git', 'diff', '--name-only', '--relative', "#{forkpoint}...HEAD")
-  end
-}
-
-
-hiiro.add_subcmd(:changed) { |*args|
-  show_all = args.delete('-a') || args.delete('--all')
-  upstream = args.first
-
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
-  }
-
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
-
-  forkpoint = `git merge-base --fork-point #{upstream} HEAD 2>/dev/null`.strip
-  if forkpoint.empty?
-    forkpoint = `git merge-base #{upstream} HEAD 2>/dev/null`.strip
-  end
-
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
-
-  if show_all
-    system('git', 'diff', '--name-only', "#{forkpoint}...HEAD")
-  else
-    system('git', 'diff', '--name-only', '--relative', "#{forkpoint}...HEAD")
-  end
-}
-
 hiiro.add_subcmd(:ancestor) { |*args|
   case args.length
   when 0
@@ -458,4 +401,6 @@ hiiro.add_subcmd(:ancestor) { |*args|
   end
 }
 
+hiiro.add_default { manager.help }
+
 hiiro.run

data/bin/h-pane

@@ -60,6 +60,17 @@ o.add_subcmd(:resize) { |*args|
   system('tmux', 'resize-pane', *args)
 }
 
+o.add_subcmd(:history) { |pane_id=nil|
+  entries = Hiiro::History.by_pane(pane_id)
+  if entries.empty?
+    puts "No history for this pane"
+  else
+    puts "History for pane: #{pane_id || ENV['TMUX_PANE'] || 'current'}"
+    puts
+    entries.last(20).each_with_index { |e, i| puts e.oneline(i + 1) }
+  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

data/bin/h-pr

@@ -21,6 +21,10 @@ class PRManager
     puts
     puts "Subcommands:"
     puts "  save [PR_NUMBER]      Record PR for this task (auto-detects if omitted)"
+    puts "  history               List PR history (oldest to newest)"
+    puts "  history --worktree=X  Filter by worktree"
+    puts "  history --task=X      Filter by task"
+    puts "  history --session=X   Filter by tmux session"
     puts "  current               Show current branch's PR info"
     puts "  open [PR_NUMBER]      Open PR in browser"
     puts "  view [PR_NUMBER]      View PR details in terminal"
@@ -63,6 +67,35 @@ class PRManager
     true
   end
 
+  def history(args = [])
+    filters = parse_filters(args)
+    data = load_data
+    prs = data['prs'] || []
+
+    if prs.empty?
+      puts "No PRs recorded."
+      puts "Use 'h pr save' to record the current PR."
+      return
+    end
+
+    # Apply filters
+    prs = filter_entries(prs, filters)
+
+    if prs.empty?
+      puts "No PRs match the given filters."
+      return
+    end
+
+    # Sort by created_at (oldest first)
+    prs = prs.sort_by { |p| p['created_at'] || '' }
+
+    puts "PR history (oldest to newest):"
+    puts
+    prs.each_with_index do |pr, idx|
+      puts format_entry(pr, idx + 1)
+    end
+  end
+
   def current
     pr_info = fetch_pr_info
     unless pr_info
@@ -136,6 +169,36 @@ class PRManager
     }
   end
 
+  def parse_filters(args)
+    filters = {}
+    args.each do |arg|
+      case arg
+      when /^--worktree=(.+)$/
+        filters[:worktree] = $1
+      when /^--task=(.+)$/
+        filters[:task] = $1
+      when /^--session=(.+)$/
+        filters[:session] = $1
+      when /^-w(.+)$/
+        filters[:worktree] = $1
+      when /^-t(.+)$/
+        filters[:task] = $1
+      when /^-s(.+)$/
+        filters[:session] = $1
+      end
+    end
+    filters
+  end
+
+  def filter_entries(entries, filters)
+    entries.select do |entry|
+      next false if filters[:worktree] && !entry['worktree']&.include?(filters[:worktree])
+      next false if filters[:task] && !entry['task']&.include?(filters[:task])
+      next false if filters[:session] && entry.dig('tmux', 'session') != filters[:session]
+      true
+    end
+  end
+
   def format_entry(entry, num)
     lines = []
     lines << "#{num}. PR ##{entry['number']}: #{entry['title']}"
@@ -478,6 +541,7 @@ hiiro.add_subcmd(:link) { |*args|
 
 hiiro.add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }
 hiiro.add_subcmd(:save) { |pr_number=nil| manager.save(pr_number) }
+hiiro.add_subcmd(:history) { |*args| manager.history(args) }
 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) }

data/bin/h-session

@@ -60,4 +60,16 @@ o.add_subcmd(:info) { |*args|
   system('tmux', 'display-message', '-p', '#{session_name}: #{session_windows} windows, #{session_attached} attached', *args)
 }
 
+o.add_subcmd(:history) { |session_name=nil|
+  session_name ||= `tmux display-message -p '#S'`.strip if ENV['TMUX']
+  entries = Hiiro::History.by_session(session_name)
+  if entries.empty?
+    puts "No history for this session"
+  else
+    puts "History for session: #{session_name || 'current'}"
+    puts
+    entries.last(20).each_with_index { |e, i| puts e.oneline(i + 1) }
+  end
+}
+
 o.run

data/bin/h-window

@@ -56,6 +56,18 @@ o.add_subcmd(:unlink) { |*args|
   system('tmux', 'unlink-window', *args)
 }
 
+o.add_subcmd(:history) { |window_id=nil|
+  window_id ||= `tmux display-message -p '#I'`.strip if ENV['TMUX']
+  entries = Hiiro::History.by_window(window_id)
+  if entries.empty?
+    puts "No history for this window"
+  else
+    puts "History for window: #{window_id || 'current'}"
+    puts
+    entries.last(20).each_with_index { |e, i| puts e.oneline(i + 1) }
+  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

data/lib/hiiro/history/entry.rb

@@ -0,0 +1,136 @@
+class Hiiro
+  class History
+    class Entry
+      FIELDS = %i[
+        id timestamp source cmd description pwd
+        tmux_session tmux_window tmux_pane
+        git_branch git_sha git_origin_sha git_worktree
+        task subtask app
+      ].freeze
+
+      attr_reader(*FIELDS)
+
+      def initialize(data)
+        data ||= {}
+        @id = data['id']
+        @timestamp = data['timestamp']
+        @source = data['source']
+        @cmd = data['cmd']
+        @description = data['description']
+        @pwd = data['pwd']
+        @tmux_session = data['tmux_session']
+        @tmux_window = data['tmux_window']
+        @tmux_pane = data['tmux_pane']
+        @git_branch = data['git_branch']
+        @git_sha = data['git_sha']
+        @git_origin_sha = data['git_origin_sha']
+        @git_worktree = data['git_worktree']
+        @task = data['task']
+        @subtask = data['subtask']
+        @app = data['app']
+      end
+
+      def to_h
+        {
+          'id' => id,
+          'timestamp' => timestamp,
+          'source' => source,
+          'cmd' => cmd,
+          'description' => description,
+          'pwd' => pwd,
+          'tmux_session' => tmux_session,
+          'tmux_window' => tmux_window,
+          'tmux_pane' => tmux_pane,
+          'git_branch' => git_branch,
+          'git_sha' => git_sha,
+          'git_origin_sha' => git_origin_sha,
+          'git_worktree' => git_worktree,
+          'task' => task,
+          'subtask' => subtask,
+          'app' => app,
+        }.compact
+      end
+
+      # Data used for change detection (excludes timestamp, id, cmd)
+      def state_key
+        {
+          'pwd' => pwd,
+          'tmux_session' => tmux_session,
+          'tmux_window' => tmux_window,
+          'tmux_pane' => tmux_pane,
+          'git_branch' => git_branch,
+          'git_sha' => git_sha,
+          'git_origin_sha' => git_origin_sha,
+          'git_worktree' => git_worktree,
+          'task' => task,
+          'subtask' => subtask,
+          'app' => app,
+        }.compact
+      end
+
+      def state_fingerprint
+        Digest::SHA256.hexdigest(state_key.to_yaml)[0..15]
+      end
+
+      def short_line(index)
+        time_str = timestamp ? Time.parse(timestamp).strftime('%Y-%m-%d %H:%M') : Time.now.strftime('%Y-%m-%d %H:%M')
+        desc = description || cmd || '(no description)'
+        desc = desc[0..50] + '...' if desc.length > 53
+        [
+          format('%3d  %s  %s', index, time_str, desc),
+          format('     %s @ %s', git_branch || '(no branch)', task || '(no task)'),
+        ].join("\n")
+      end
+
+      def oneline(index = nil)
+        time_str = timestamp ? Time.parse(timestamp).strftime('%m/%d %H:%M') : ''
+        prefix = index ? format('%3d  ', index) : ''
+        sha_str = git_sha ? git_sha[0..6] : '-------'
+        branch_str = git_branch ? "[#{git_branch}]" : ''
+        task_str = task ? "(#{task})" : ''
+        cmd_str = cmd || description || ''
+        cmd_str = cmd_str[0..35] + '...' if cmd_str.length > 38
+
+        "#{prefix}#{time_str}  #{sha_str}  #{branch_str.ljust(20)}  #{task_str.ljust(15)}  #{cmd_str}"
+      end
+
+      def full_display
+        lines = []
+        lines << "ID:          #{id}"
+        lines << "Timestamp:   #{timestamp}"
+        lines << "Description: #{description}" if description
+        lines << "Command:     #{cmd}" if cmd
+        lines << "PWD:         #{pwd}" if pwd
+        lines << "Source:      #{source}" if source
+        lines << ""
+        lines << "Tmux:"
+        lines << "  Session:   #{tmux_session}" if tmux_session
+        lines << "  Window:    #{tmux_window}" if tmux_window
+        lines << "  Pane:      #{tmux_pane}" if tmux_pane
+        lines << ""
+        lines << "Git:"
+        lines << "  Worktree:  #{git_worktree}" if git_worktree
+        lines << "  Branch:    #{git_branch}" if git_branch
+        lines << "  SHA:       #{git_sha}" if git_sha
+        lines << "  Origin:    #{git_origin_sha}" if git_origin_sha
+        lines << ""
+        lines << "Task:"
+        lines << "  Task:      #{task}" if task
+        lines << "  Subtask:   #{subtask}" if subtask
+        lines << "  App:       #{app}" if app
+        lines.join("\n")
+      end
+
+      # Filter matching
+      def matches?(filters)
+        filters.all? do |key, value|
+          entry_value = send(key) rescue nil
+          next true if value.nil?
+          next entry_value == value if value.is_a?(String)
+          next value.include?(entry_value) if value.is_a?(Array)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/hiiro/history.rb

@@ -0,0 +1,454 @@
+require 'yaml'
+require 'time'
+require 'fileutils'
+require 'digest'
+require_relative 'history/entry'
+
+class Hiiro
+  class History
+    HISTORY_DIR = File.join(Dir.home, '.config/hiiro/history')
+    HISTORY_FILE = File.join(HISTORY_DIR, 'entries.yml')
+    LAST_STATE_FILE = File.join(HISTORY_DIR, 'last_state.yml')
+
+    class << self
+      def load(hiiro)
+        history = new
+
+        hiiro.add_subcmd(:history) do |*args|
+          subcmd, *rest = args
+          case subcmd
+          when 'ls', 'list', nil
+            history.list(limit: 20)
+          when 'all'
+            history.list(limit: nil)
+          when 'show'
+            history.show(rest.first)
+          when 'goto'
+            history.goto(rest.first)
+          when 'add'
+            history.add_manual(rest.join(' '), hiiro: hiiro)
+          when 'by'
+            # h history by pane|window|session|task|branch [value]
+            dimension, value = rest
+            history.list_by(dimension, value)
+          when 'clear'
+            history.clear!
+            puts "History cleared."
+          else
+            puts "Unknown history subcommand: #{subcmd}"
+            puts "Available: ls, all, show <id>, goto <id>, add <description>, by <dimension> [value], clear"
+            false
+          end
+        end
+      end
+
+      # Called automatically when a command runs (if in a task context)
+      def track(cmd:, hiiro: nil)
+        new.track_command(cmd: cmd, hiiro: hiiro)
+      end
+
+      def log(description: nil, pwd: Dir.pwd, cmd: nil, source: nil, task: nil, subtask: nil)
+        new.add(
+          description: description,
+          cmd: cmd,
+          pwd: pwd,
+          source: source,
+          task: task,
+          subtask: subtask
+        )
+      end
+
+      # Query helpers for other commands (e.g., h pane history)
+      def by_pane(pane_id = nil)
+        pane_id ||= current_tmux_pane
+        new.filter(tmux_pane: pane_id)
+      end
+
+      def by_window(window_id = nil)
+        window_id ||= current_tmux_window
+        new.filter(tmux_window: window_id)
+      end
+
+      def by_session(session_name = nil)
+        session_name ||= current_tmux_session
+        new.filter(tmux_session: session_name)
+      end
+
+      def by_task(task_name)
+        new.filter(task: task_name)
+      end
+
+      def by_branch(branch_name)
+        new.filter(git_branch: branch_name)
+      end
+
+      def by_worktree(worktree_path)
+        new.filter(git_worktree: worktree_path)
+      end
+
+      def by_app(app_name)
+        new.filter(app: app_name)
+      end
+
+      private
+
+      def current_tmux_pane
+        return nil unless ENV['TMUX']
+        `tmux display-message -p '#D'`.strip rescue nil
+      end
+
+      def current_tmux_window
+        return nil unless ENV['TMUX']
+        `tmux display-message -p '#S:#I'`.strip rescue nil
+      end
+
+      def current_tmux_session
+        return nil unless ENV['TMUX']
+        `tmux display-message -p '#S'`.strip rescue nil
+      end
+    end
+
+    def initialize
+      ensure_history_dir
+    end
+
+    def entries
+      @entries ||= load_entries
+    end
+
+    def reload
+      @entries = nil
+      entries
+    end
+
+    def filter(filters = {})
+      entries.select { |e| e.matches?(filters) }
+    end
+
+    def list(limit: 20)
+      items = entries.reverse
+      items = items.first(limit) if limit
+
+      if items.empty?
+        puts "No history entries."
+        return true
+      end
+
+      items.reverse.each_with_index do |entry, idx|
+        puts entry.oneline(idx + 1)
+      end
+      true
+    end
+
+    def list_by(dimension, value = nil)
+      dimension_map = {
+        'pane' => :tmux_pane,
+        'window' => :tmux_window,
+        'session' => :tmux_session,
+        'task' => :task,
+        'subtask' => :subtask,
+        'branch' => :git_branch,
+        'worktree' => :git_worktree,
+        'app' => :app,
+      }
+
+      field = dimension_map[dimension]
+      unless field
+        puts "Unknown dimension: #{dimension}"
+        puts "Available: #{dimension_map.keys.join(', ')}"
+        return false
+      end
+
+      # If no value specified, use current context
+      value ||= current_value_for(field)
+
+      if value.nil?
+        puts "No current #{dimension} detected. Please specify a value."
+        return false
+      end
+
+      filtered = filter(field => value)
+
+      if filtered.empty?
+        puts "No history for #{dimension}=#{value}"
+        return true
+      end
+
+      puts "History for #{dimension}: #{value}"
+      puts
+      filtered.last(20).each_with_index do |entry, idx|
+        puts entry.oneline(idx + 1)
+      end
+      true
+    end
+
+    def show(ref)
+      entry = find_entry(ref)
+      unless entry
+        puts "Entry not found: #{ref}"
+        return false
+      end
+
+      puts entry.full_display
+      true
+    end
+
+    def goto(ref)
+      entry = find_entry(ref)
+      unless entry
+        puts "Entry not found: #{ref}"
+        return false
+      end
+
+      unless entry.tmux_session
+        puts "No tmux session recorded for this entry"
+        return false
+      end
+
+      target = entry.tmux_session
+      target += ":#{entry.tmux_window}" if entry.tmux_window
+      target += ".#{entry.tmux_pane}" if entry.tmux_pane
+
+      system('tmux', 'switch-client', '-t', target)
+    end
+
+    def add_manual(description, hiiro: nil)
+      add(
+        description: description,
+        source: 'manual',
+        cmd: hiiro&.full_command,
+      )
+      true
+    end
+
+    # Main tracking method - gathers all context and saves if changed
+    def track_command(cmd:, hiiro: nil, force: false)
+      context = gather_context
+      return nil unless context[:task] || force # Only track if in a task context (unless forced)
+
+      context[:cmd] = cmd
+      context[:source] = 'auto'
+
+      # Check if state changed
+      unless force
+        new_state = build_state_key(context)
+        return nil if state_unchanged?(new_state)
+        save_last_state(new_state)
+      end
+
+      add(**context)
+    end
+
+    def add(
+      description: nil, cmd: nil, source: nil, pwd: nil,
+      tmux_session: nil, tmux_window: nil, tmux_pane: nil,
+      git_branch: nil, git_sha: nil, git_origin_sha: nil, git_worktree: nil,
+      task: nil, subtask: nil, app: nil
+    )
+      context = gather_context
+
+      entry_data = {
+        'id' => generate_id,
+        'timestamp' => Time.now.iso8601,
+        'description' => description,
+        'cmd' => cmd,
+        'pwd' => pwd || context[:pwd],
+        'source' => source,
+        'tmux_session' => tmux_session || context[:tmux_session],
+        'tmux_window' => tmux_window || context[:tmux_window],
+        'tmux_pane' => tmux_pane || context[:tmux_pane],
+        'git_branch' => git_branch || context[:git_branch],
+        'git_sha' => git_sha || context[:git_sha],
+        'git_origin_sha' => git_origin_sha || context[:git_origin_sha],
+        'git_worktree' => git_worktree || context[:git_worktree],
+        'task' => task || context[:task],
+        'subtask' => subtask || context[:subtask],
+        'app' => app || context[:app],
+      }.compact
+
+      all = load_raw_entries
+      all << entry_data
+      save_entries(all)
+
+      Entry.new(entry_data)
+    end
+
+    def clear!
+      save_entries([])
+      File.delete(LAST_STATE_FILE) if File.exist?(LAST_STATE_FILE)
+      @entries = nil
+    end
+
+    private
+
+    def gather_context
+      {
+        pwd: Dir.pwd,
+        tmux_session: current_tmux_session,
+        tmux_window: current_tmux_window,
+        tmux_pane: current_tmux_pane,
+        git_branch: current_git_branch,
+        git_sha: current_git_sha,
+        git_origin_sha: current_git_origin_sha,
+        git_worktree: current_git_worktree,
+        task: current_task_name,
+        subtask: current_subtask_name,
+        app: current_app_name,
+      }
+    end
+
+    def build_state_key(context)
+      context.slice(
+        :pwd, :tmux_session, :tmux_window, :tmux_pane,
+        :git_branch, :git_sha, :git_origin_sha, :git_worktree,
+        :task, :subtask, :app
+      ).compact
+    end
+
+    def state_unchanged?(new_state)
+      return false unless File.exist?(LAST_STATE_FILE)
+      last_state = YAML.load_file(LAST_STATE_FILE) rescue {}
+      last_state == new_state.transform_keys(&:to_s)
+    end
+
+    def save_last_state(state)
+      File.write(LAST_STATE_FILE, state.transform_keys(&:to_s).to_yaml)
+    end
+
+    def current_value_for(field)
+      context = gather_context
+      context[field]
+    end
+
+    def find_entry(ref)
+      return nil unless ref
+
+      if ref.to_s.match?(/^\d+$/)
+        idx = ref.to_i - 1
+        reversed = entries.reverse
+        return reversed[idx] if idx >= 0 && idx < reversed.length
+      end
+
+      entries.find { |e| e.id == ref.to_s }
+    end
+
+    def generate_id
+      Time.now.strftime('%Y%m%d%H%M%S') + '-' + rand(10000).to_s.rjust(4, '0')
+    end
+
+    def ensure_history_dir
+      FileUtils.mkdir_p(HISTORY_DIR) unless Dir.exist?(HISTORY_DIR)
+
+      unless File.exist?(HISTORY_FILE)
+        File.write(HISTORY_FILE, [].to_yaml)
+      end
+    end
+
+    def load_raw_entries
+      YAML.load_file(HISTORY_FILE) || []
+    rescue => e
+      []
+    end
+
+    def load_entries
+      load_raw_entries.map { |data| Entry.new(data) }
+    end
+
+    def save_entries(entries_data)
+      # Keep only last 1000 entries to prevent unbounded growth
+      entries_data = entries_data.last(1000) if entries_data.length > 1000
+      File.write(HISTORY_FILE, entries_data.to_yaml)
+    end
+
+    # Tmux context
+    def current_tmux_session
+      return nil unless ENV['TMUX']
+      `tmux display-message -p '#S'`.strip rescue nil
+    end
+
+    def current_tmux_window
+      return nil unless ENV['TMUX']
+      `tmux display-message -p '#I'`.strip rescue nil
+    end
+
+    def current_tmux_pane
+      return nil unless ENV['TMUX']
+      ENV['TMUX_PANE'] || `tmux display-message -p '#P'`.strip rescue nil
+    end
+
+    # Git context
+    def current_git_branch
+      git_helper.branch_current
+    end
+
+    def current_git_sha
+      git_helper.commit('HEAD')
+    end
+
+    def current_git_origin_sha
+      branch = current_git_branch
+      return nil unless branch
+      git_helper.commit("origin/#{branch}")
+    end
+
+    def current_git_worktree
+      git_helper.root
+    end
+
+    def git_helper
+      @git_helper ||= Git.new(nil, Dir.pwd)
+    end
+
+    # Task context
+    def current_task_name
+      env = environment
+      return nil unless env
+
+      task = env.task
+      return nil unless task
+
+      task.subtask? ? task.parent_name : task.name
+    end
+
+    def current_subtask_name
+      env = environment
+      return nil unless env
+
+      task = env.task
+      return nil unless task
+      return nil unless task.subtask?
+
+      task.short_name
+    end
+
+    def current_app_name
+      env = environment
+      return nil unless env
+
+      pwd = Dir.pwd
+      task = env.task
+      return nil unless task
+
+      tree = env.find_tree(task.tree_name)
+      return nil unless tree
+
+      # Check if pwd is in an app directory
+      env.all_apps.each do |app|
+        app_path = app.resolve(tree.path)
+        if pwd == app_path || pwd.start_with?(app_path + '/')
+          return app.name
+        end
+      end
+
+      nil
+    end
+
+    def environment
+      @environment ||= begin
+        Environment.current
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/hiiro/shell.rb

@@ -0,0 +1,19 @@
+require 'open3'
+
+class Hiiro
+  class Shell
+    def self.pipe_lines(lines, *command)
+      content = lines.is_a?(Array) ? lines.join("\n") : lines.to_s
+
+      pipe(content, *command)
+    end
+
+    def self.pipe(content, *command)
+      selected, status = Open3.capture2(*command, stdin_data: content)
+
+      return nil unless status.success?
+
+      selected&.chomp
+    end
+  end
+end

data/lib/hiiro/sk.rb

@@ -1,17 +1,10 @@
 require 'open3'
+require_relative 'shell'
 
 class Hiiro
   class Sk
     def self.select(lines)
-      input = lines.is_a?(Array) ? lines.join("\n") : lines.to_s
-      selected, status = Open3.capture2('sk', stdin_data: input)
-
-      return nil unless status.success?
-
-      result = selected.strip
-      return nil if result.empty?
-
-      result
+      Shell.pipe_lines(lines, 'sk')
     end
 
     def self.map_select(mapping)

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.85"
+  VERSION = "0.1.86"
 end

data/lib/hiiro.rb

@@ -6,6 +6,7 @@ require "pry"
 require_relative "hiiro/version"
 require_relative "hiiro/prefix_matcher"
 require_relative "hiiro/git"
+require_relative "hiiro/history"
 require_relative "hiiro/options"
 require_relative "hiiro/notification"
 require_relative "hiiro/sk"
@@ -38,6 +39,7 @@ class Hiiro
     bin_name = values[:bin_name] || $0
 
     new(bin_name, *args, logging: logging, **values).tap do |hiiro|
+      History.load(hiiro)
       hiiro.load_plugins(*plugins)
 
       hiiro.add_subcommand(:pry) { |*args|
@@ -102,9 +104,16 @@ class Hiiro
     @todo_manager ||= TodoManager.new
   end
 
+  def history
+    @history ||= History.new
+  end
+
   def run
     result = runner.run(*args)
 
+    # Track command after running (only saves if state changed and in task context)
+    History.track(cmd: full_command, hiiro: self)
+
     handle_result(result)
 
     exit 1

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.85
+  version: 0.1.86
 platform: ruby
 authors:
 - Joshua Toyota
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -101,9 +100,12 @@ files:
 - lib/hiiro/git/remote.rb
 - lib/hiiro/git/worktree.rb
 - lib/hiiro/git/worktrees.rb
+- lib/hiiro/history.rb
+- lib/hiiro/history/entry.rb
 - lib/hiiro/notification.rb
 - lib/hiiro/options.rb
 - lib/hiiro/prefix_matcher.rb
+- lib/hiiro/shell.rb
 - lib/hiiro/sk.rb
 - lib/hiiro/todo.rb
 - lib/hiiro/version.rb
@@ -126,7 +128,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
@@ -141,8 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A lightweight CLI framework for Ruby
 test_files: []