hiiro 0.1.82 → 0.1.83

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31fd73a56f9bbcc10a8a9e62ecdd0dcbc391eb65e0bcf5886ab289986f81a198
-  data.tar.gz: dd392dc066b2ec7c894a2d7c2d14c8d2921f157a4b998dde9ee7ffdb83400844
+  metadata.gz: 599e565871c2afc37ae659954e4ccf01568bed4375032fb9d8ba21007e7e2673
+  data.tar.gz: 4fdcbf43a79f2b63ec3f95ecd003973cb3175b4ef0b6cdbb0cbc36444439b259
 SHA512:
-  metadata.gz: 705c6f8c3aa58a2f356272a647d67fb84a7b7c6c39b271c2372e4b3498a0d644415a75d2fad9ff16c80a73949fdc432052e6ef7d00e97149c412eb290c1fb13a
-  data.tar.gz: df6abb83f94c9433a992f359d66393c8c3c9db28c5d920d32529bf58a3fe536114da0396298fdf4400b062058acb054e57dc83696d5d5ada96a9319ef8ee5e86
+  metadata.gz: e8945bc066927371fa804f6b0deef00ee36f84be0fc9178033e52d5228ce5f6b895b114cb3a0a37129e491f2c8d4a1156cfce36e18740d28048fa7885ad1f792
+  data.tar.gz: 31acaf4e204e3be5f8c6fddbf6009f0e757bad86e3dcbe5c770637c05d848a6c4a65c42552617e015bd8b55171aecc9d2fde86b58e6b16ed06ef23f8bdef6179

data/bin/h-branch

@@ -19,10 +19,6 @@ class BranchManager
     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
 
@@ -62,35 +58,6 @@ 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
@@ -132,48 +99,6 @@ 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)'}"
@@ -204,7 +129,6 @@ 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) { manager.current }
 hiiro.add_subcmd(:select) do |*args|
   branches = hiiro.git.branches(sort_by: 'authordate', ignore_case: true)
@@ -375,6 +299,115 @@ 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

data/bin/h-pane

@@ -60,17 +60,6 @@ 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,10 +21,6 @@ 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"
@@ -67,35 +63,6 @@ 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
@@ -169,36 +136,6 @@ 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']}"
@@ -541,7 +478,6 @@ 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,16 +60,4 @@ 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,18 +56,6 @@ 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/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.82"
+  VERSION = "0.1.83"
 end

data/lib/hiiro.rb

@@ -6,7 +6,6 @@ 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"
@@ -39,7 +38,6 @@ 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|
@@ -104,16 +102,9 @@ 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,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.82
+  version: 0.1.83
 platform: ruby
 authors:
 - Joshua Toyota
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -100,8 +101,6 @@ 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
@@ -127,6 +126,7 @@ 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,7 +141,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: A lightweight CLI framework for Ruby
 test_files: []

data/lib/hiiro/history/entry.rb

@@ -1,136 +0,0 @@
-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

@@ -1,454 +0,0 @@
-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