hiiro 0.1.93 → 0.1.94

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f361a37f0791f6a855fe07229596c3f8848f13b82e2ee6c0fb55ae707a3a001
-  data.tar.gz: 81be58360c900b6d74e3d33a59cfbe052a8ef8be823cc8143e9b6709c3c10e22
+  metadata.gz: 215c78065501f35e2e1e6534dd08a3adfc9d58b62650bf65be84c32004bcf651
+  data.tar.gz: b27dcfdb0aba3dc63d2d102c0d62dc67a4bc8176f304499e49574c7db28ea340
 SHA512:
-  metadata.gz: 13bf9c867a91ae8c3cf006012d769212b16c1c17bf02cc4613f41e40faf50a2de88e0ab669e0dfa50ca7e5ca6ef4ef5a10f84a4acfa03f50e2dbf1c3e3c68750
-  data.tar.gz: fe045f0ad9b13b19705f2e80e2b3dbe5fc36fb00bbe6eefb99f33d7bb6e76fe789bb1ed410539731f47a1bf69d0efb2eb81b8bb949a1d99c7a78599af763fdc6
+  metadata.gz: 361003e1b599d031c386aaad3f4fb476267f336193f89ae113dd9e5d96a3a609385068b29ba41c9d8bd8dd7899aa0ca10dbf639a4a05295cee10e38a011a375b
+  data.tar.gz: 1d1aa957c67ff43adc4194397e5e4ff8e789e76792e2a2f758139903bb8f5934856115f122755e0ba92fa87a1f229a5a57d69896b808de77effc511563633cfd

data/CLAUDE.md

@@ -69,12 +69,14 @@ Plugins auto-load from `~/.config/hiiro/plugins/`. Load order matters when plugi
 
 ### Global Values Pattern
 
-Values passed to `Hiiro.init()` are available in subcommand handlers:
+Values passed to `Hiiro.run()` are available in subcommand handlers:
 
 ```ruby
-hiiro = Hiiro.init(*ARGV, cwd: Dir.pwd)
-hiiro.add_subcmd(:pwd) do |*args, **values|
-  puts values[:cwd]
+Hiiro.run(*ARGV, cwd: Dir.pwd) do
+  add_subcmd(:pwd) { |*args|
+    cwd = get_value(:cwd)
+    puts cwd
+  }
 end
 ```
 
@@ -126,10 +128,10 @@ end
 def self.build_hiiro(parent_hiiro, tm)
   bin_name = [parent_hiiro.bin, parent_hiiro.subcmd || ''].join('-')
 
-  Hiiro.init(bin_name:, args: parent_hiiro.args) do |h|
-    h.add_subcmd(:list) { tm.list }
-    h.add_subcmd(:start) { |name| tm.start_task(name) }
-    h.add_subcmd(:switch) { |name=nil|
+  Hiiro.run(bin_name:, args: parent_hiiro.args) do
+    add_subcmd(:list) { tm.list }
+    add_subcmd(:start) { |name| tm.start_task(name) }
+    add_subcmd(:switch) { |name=nil|
       name ||= tm.select_task_interactive
       tm.switch_to_task(tm.task_by_name(name))
     }
@@ -150,7 +152,7 @@ The `lib/hiiro.rb` file and `lib/hiiro/` directory contain the core framework cl
 
 Main entry point with class methods:
 - `Hiiro.run(*ARGV, plugins: [...]) { ... }` - Initialize and run immediately
-- `Hiiro.init(*ARGV, plugins: [...]) { ... }` - Initialize without running (returns hiiro instance)
+- `Hiiro.init(*ARGV, plugins: [...]) { ... }` - Initialize without running (returns hiiro instance).  **NEVER USE THIS** without a good reason, always favor `Hiiro.run`
 
 Instance methods available in subcommand blocks:
 - `git` - Returns `Hiiro::Git` instance for git operations
@@ -264,3 +266,17 @@ All config lives in `~/.config/hiiro/`:
 - `tasks/` - Task metadata for worktree management
 - `projects.yml` - Project directory aliases
 - `apps.yml` - App directory mappings for task plugin
+
+
+# Groups of files
+
+## tmux-related files
+
+- bin/h-buffer
+- bin/h-pane
+- bin/h-window
+- bin/h-session
+- lib/hiiro/tmux.rb
+- lib/hiiro/tmux/*
+
+

data/bin/h-branch

@@ -5,7 +5,6 @@ require "fileutils"
 require "yaml"
 
 Hiiro.load_env
-hiiro = Hiiro.init(*ARGV, plugins: [Tasks])
 
 class BranchManager
   attr_reader :hiiro
@@ -117,344 +116,284 @@ class BranchManager
   end
 end
 
-manager = BranchManager.new(hiiro)
+Hiiro.run(*ARGV, plugins: [Tasks]) do
+  manager = BranchManager.new(self)
 
-hiiro.add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }
-hiiro.add_subcmd(:save) { manager.save }
-hiiro.add_subcmd(:current) { print `git branch --show-current` }
-hiiro.add_subcmd(:info) { manager.current }
-hiiro.add_subcmd(:select) do |*args|
-  branches = hiiro.git.branches(sort_by: 'authordate', ignore_case: true)
+  add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }
+  add_subcmd(:save) { manager.save }
+  add_subcmd(:current) { print `git branch --show-current` }
+  add_subcmd(:info) { manager.current }
 
-  lines = branches.each_with_object({}) do |name, h|
-    h["  #{name}"] = name
-  end
-
-  if args.any?
-    lines = hash_matches?(lines, *args)
-  end
-
-  require 'open3'
-  selected, status = Open3.capture2('sk', '--no-sort', '--tac', stdin_data: lines.keys.join("\n"))
-
-  if status.success? && !selected.strip.empty?
-    puts lines[selected.chomp]
-  end
-end
+  add_subcmd(:select) do |*select_args|
+    branches = git.branches(sort_by: 'authordate', ignore_case: true)
 
-checkout_branch = lambda { |branch = nil, *args|
-  unless branch
-    # Use sk to select a branch
-    branches = hiiro.git.branches(sort_by: 'authordate', ignore_case: true)
-    require 'open3'
-    selected, status = Open3.capture2('sk', '--no-sort', '--tac', stdin_data: branches.join("\n"))
-    unless status.success? && !selected.strip.empty?
-      puts "No branch selected"
-      next
+    lines = branches.each_with_object({}) do |name, h|
+      h["  #{name}"] = name
     end
-    branch = selected.strip
-  end
-
-  system('git', 'checkout', branch, *args)
-}
-
-hiiro.add_subcmd(:checkout, &checkout_branch)
-hiiro.add_subcmd(:co, &checkout_branch)
 
-remove_branch = lambda { |branch = nil, *args|
-  unless branch
-    # Use sk to select a branch
-    branches = hiiro.git.branches(sort_by: 'authordate', ignore_case: true)
-    require 'open3'
-    selected, status = Open3.capture2('sk', '--no-sort', '--tac', stdin_data: branches.join("\n"))
-    unless status.success? && !selected.strip.empty?
-      puts "No branch selected"
-      next
+    if select_args.any?
+      lines = hash_matches?(lines, *select_args)
     end
-    branch = selected.strip
-  end
 
-  system('git', 'branch', '-d', branch, *args)
-}
-
-hiiro.add_subcmd(:remove, &remove_branch)
-hiiro.add_subcmd(:rm, &remove_branch)
+    require 'open3'
+    selected, status = Open3.capture2('sk', '--no-sort', '--tac', stdin_data: lines.keys.join("\n"))
 
-hiiro.add_subcmd(:duplicate) { |new_name = nil, source = nil|
-  unless new_name
-    puts "Usage: h branch duplicate <new_name> [source_branch]"
-    puts "  Creates a copy of source_branch (or current branch) as new_name"
-    next
+    if status.success? && !selected.strip.empty?
+      puts lines[selected.chomp]
+    end
   end
 
-  source ||= hiiro.git.branch
-  system('git', 'branch', new_name, source)
-  puts "Created branch '#{new_name}' from '#{source}'"
-}
-
-hiiro.add_subcmd(:test) { |*args|
-  opts = Hiiro::Options.parse(args) do
-    option :remote, short: 'r', default: 'origin', desc: 'Remote name'
-    option :from, short: 'f', desc: 'Local branch or commit to push'
-    option :to, short: 't', desc: 'Remote branch name'
-    flag :force, short: 'F', desc: 'Force push'
-    flag :set_upstream, short: 'u', desc: 'Set upstream tracking'
-  end
+  checkout_branch = lambda { |branch = nil, *checkout_args|
+    unless branch
+      # Use sk to select a branch
+      branches = git.branches(sort_by: 'authordate', ignore_case: true)
+      require 'open3'
+      selected, status = Open3.capture2('sk', '--no-sort', '--tac', stdin_data: branches.join("\n"))
+      unless status.success? && !selected.strip.empty?
+        puts "No branch selected"
+        next
+      end
+      branch = selected.strip
+    end
 
-  if opts.help?
-    hiiro.help(opts)
-    return
-  end
+    system('git', 'checkout', branch, *checkout_args)
+  }
 
-  {
-    remote_as_method: opts.remote,
-    remote_as_sym_key: opts[:remote],
-    remote_as_string_key: opts['remote'],
-    force_as_method: opts.force,
-    force_as_sym_key: opts[:force],
-    force_as_string_key: opts['force'],
-  }.each do |k,v|
-    puts "#{k} => #{v}"
-  end
-}
-
-hiiro.add_subcmd(:push) { |*args|
-  opts = Hiiro::Options.parse(args) do
-    option :remote, short: 'r', default: 'origin', desc: 'Remote name'
-    option :from, short: 'f', desc: 'Local branch or commit to push'
-    option :to, short: 't', desc: 'Remote branch name'
-    flag :force, short: 'F', desc: 'Force push'
-    flag :set_upstream, short: 'u', desc: 'Set upstream tracking'
-  end
+  add_subcmd(:checkout, &checkout_branch)
+  add_subcmd(:co, &checkout_branch)
+
+  remove_branch = lambda { |branch = nil, *remove_args|
+    unless branch
+      # Use sk to select a branch
+      branches = git.branches(sort_by: 'authordate', ignore_case: true)
+      require 'open3'
+      selected, status = Open3.capture2('sk', '--no-sort', '--tac', stdin_data: branches.join("\n"))
+      unless status.success? && !selected.strip.empty?
+        puts "No branch selected"
+        next
+      end
+      branch = selected.strip
+    end
 
-  local_ref = opts[:from] || hiiro.git.branch
-  remote_branch = opts[:to] || local_ref
-
-  git_args = ['git', 'push']
-  git_args << '--force' if opts[:force]
-  git_args << '-u' if opts[:set_upstream]
-  git_args << opts[:remote]
-  git_args << "#{local_ref}:#{remote_branch}"
-
-  puts "Pushing #{local_ref} to #{opts[:remote]}/#{remote_branch}..."
-  system(*git_args)
-}
-
-hiiro.add_subcmd(:diff) { |*args|
-  case args.length
-  when 0
-    # Compare current branch to main/master
-    base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") } || 'HEAD~1'
-    range = "#{base}..HEAD"
-  when 1
-    # Compare current branch to specified ref
-    range = "#{args[0]}..HEAD"
-  else
-    # Compare two refs (from..to or from...to based on args)
-    from, to = args[0..1]
-    range = "#{from}..#{to}"
-  end
+    system('git', 'branch', '-d', branch, *remove_args)
+  }
 
-  system('git', 'log', '--oneline', '--decorate', range)
-}
+  add_subcmd(:remove, &remove_branch)
+  add_subcmd(:rm, &remove_branch)
 
-hiiro.add_subcmd(:changed) { |*args|
-  show_all = args.delete('-a') || args.delete('--all')
-  upstream = args.first
+  add_subcmd(:duplicate) { |new_name = nil, source = nil|
+    unless new_name
+      puts "Usage: h branch duplicate <new_name> [source_branch]"
+      puts "  Creates a copy of source_branch (or current branch) as new_name"
+      next
+    end
 
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
+    source ||= git.branch
+    system('git', 'branch', new_name, source)
+    puts "Created branch '#{new_name}' from '#{source}'"
   }
 
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
+  add_subcmd(:test) { |*test_args|
+    opts = Hiiro::Options.parse(test_args) do
+      option :remote, short: 'r', default: 'origin', desc: 'Remote name'
+      option :from, short: 'f', desc: 'Local branch or commit to push'
+      option :to, short: 't', desc: 'Remote branch name'
+      flag :force, short: 'F', desc: 'Force push'
+      flag :set_upstream, short: 'u', desc: 'Set upstream tracking'
+    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 opts.help?
+      help(opts)
+      return
+    end
 
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
+    {
+      remote_as_method: opts.remote,
+      remote_as_sym_key: opts[:remote],
+      remote_as_string_key: opts['remote'],
+      force_as_method: opts.force,
+      force_as_sym_key: opts[:force],
+      force_as_string_key: opts['force'],
+    }.each do |k,v|
+      puts "#{k} => #{v}"
+    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
-    base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") } || 'HEAD~1'
-    ahead_of = base
-    branch = 'HEAD'
-  when 1
-    ahead_of = args[0]
-    branch = 'HEAD'
-  else
-    ahead_of, branch = args[0..1]
-  end
+  add_subcmd(:push) { |*push_args|
+    opts = Hiiro::Options.parse(push_args) do
+      option :remote, short: 'r', default: 'origin', desc: 'Remote name'
+      option :from, short: 'f', desc: 'Local branch or commit to push'
+      option :to, short: 't', desc: 'Remote branch name'
+      flag :force, short: 'F', desc: 'Force push'
+      flag :set_upstream, short: 'u', desc: 'Set upstream tracking'
+    end
 
-  count = `git rev-list --count #{ahead_of}..#{branch}`.strip.to_i
-  puts "#{branch} is #{count} commit(s) ahead of #{ahead_of}"
-}
-
-hiiro.add_subcmd(:behind) { |*args|
-  case args.length
-  when 0
-    base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") } || 'HEAD~1'
-    behind_of = base
-    branch = 'HEAD'
-  when 1
-    behind_of = args[0]
-    branch = 'HEAD'
-  else
-    behind_of, branch = args[0..1]
-  end
+    local_ref = opts[:from] || git.branch
+    remote_branch = opts[:to] || local_ref
 
-  count = `git rev-list --count #{branch}..#{behind_of}`.strip.to_i
-  puts "#{branch} is #{count} commit(s) behind #{behind_of}"
-}
+    git_args = ['git', 'push']
+    git_args << '--force' if opts[:force]
+    git_args << '-u' if opts[:set_upstream]
+    git_args << opts[:remote]
+    git_args << "#{local_ref}:#{remote_branch}"
 
-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")
+    puts "Pushing #{local_ref} to #{opts[:remote]}/#{remote_branch}..."
+    system(*git_args)
   }
 
-  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
+  add_subcmd(:diff) { |*diff_args|
+    case diff_args.length
+    when 0
+      # Compare current branch to main/master
+      base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") } || 'HEAD~1'
+      range = "#{base}..HEAD"
+    when 1
+      # Compare current branch to specified ref
+      range = "#{diff_args[0]}..HEAD"
+    else
+      # Compare two refs (from..to or from...to based on args)
+      from, to = diff_args[0..1]
+      range = "#{from}..#{to}"
+    end
 
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
+    system('git', 'log', '--oneline', '--decorate', range)
+  }
 
-  system('git', 'log', '--oneline', '--decorate', "#{forkpoint}..HEAD")
-}
+  add_subcmd(:changed) { |*changed_args|
+    show_all = changed_args.delete('-a') || changed_args.delete('--all')
+    upstream = changed_args.first
 
-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")
-  }
+    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
+    unless upstream
+      puts "Cannot find master or origin/master"
+      next
+    end
 
-  forkpoint = `git merge-base --fork-point #{upstream} #{branch} 2>/dev/null`.strip
+    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?
-    # 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"
+      next
+    end
 
-  if forkpoint.empty?
-    puts "Could not find fork point between #{upstream} and #{branch}"
-  else
-    puts forkpoint
-  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
+  add_subcmd(:ahead) { |*ahead_args|
+    case ahead_args.length
+    when 0
+      base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") } || 'HEAD~1'
+      ahead_of = base
+      branch = 'HEAD'
+    when 1
+      ahead_of = ahead_args[0]
+      branch = 'HEAD'
+    else
+      ahead_of, branch = ahead_args[0..1]
+    end
 
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
+    count = `git rev-list --count #{ahead_of}..#{branch}`.strip.to_i
+    puts "#{branch} is #{count} commit(s) ahead of #{ahead_of}"
   }
 
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
+  add_subcmd(:behind) { |*behind_args|
+    case behind_args.length
+    when 0
+      base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") } || 'HEAD~1'
+      behind_of = base
+      branch = 'HEAD'
+    when 1
+      behind_of = behind_args[0]
+      branch = 'HEAD'
+    else
+      behind_of, branch = behind_args[0..1]
+    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
+    count = `git rev-list --count #{branch}..#{behind_of}`.strip.to_i
+    puts "#{branch} is #{count} commit(s) behind #{behind_of}"
+  }
 
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
+  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")
+    }
 
-  if show_all
-    system('git', 'diff', '--name-only', "#{forkpoint}...HEAD")
-  else
-    system('git', 'diff', '--name-only', '--relative', "#{forkpoint}...HEAD")
-  end
-}
+    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
 
-hiiro.add_subcmd(:changed) { |*args|
-  show_all = args.delete('-a') || args.delete('--all')
-  upstream = args.first
+    if forkpoint.empty?
+      puts "Could not find fork point"
+      next
+    end
 
-  upstream ||= %w[origin/master master origin/main main].find { |ref|
-    system("git rev-parse --verify #{ref} >/dev/null 2>&1")
+    system('git', 'log', '--oneline', '--decorate', "#{forkpoint}..HEAD")
   }
 
-  unless upstream
-    puts "Cannot find master or origin/master"
-    next
-  end
+  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")
+    }
 
-  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
+    unless upstream
+      puts "Cannot find master or origin/master"
+      next
+    end
 
-  if forkpoint.empty?
-    puts "Could not find fork point"
-    next
-  end
+    forkpoint = `git merge-base --fork-point #{upstream} #{branch} 2>/dev/null`.strip
 
-  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
-    # Check if main/master is ancestor of HEAD
-    base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") }
-    unless base
-      puts "Cannot find main or master branch"
-      next
+    if forkpoint.empty?
+      # Fallback to regular merge-base if fork-point fails
+      forkpoint = `git merge-base #{upstream} #{branch} 2>/dev/null`.strip
     end
-    ancestor = base
-    descendant = 'HEAD'
-  when 1
-    # Check if arg is ancestor of HEAD
-    ancestor = args[0]
-    descendant = 'HEAD'
-  else
-    ancestor, descendant = args[0..1]
-  end
 
-  if system("git merge-base --is-ancestor #{ancestor} #{descendant}")
-    puts "Yes, #{ancestor} is an ancestor of #{descendant}"
-  else
-    puts "No, #{ancestor} is NOT an ancestor of #{descendant}"
-  end
-}
+    if forkpoint.empty?
+      puts "Could not find fork point between #{upstream} and #{branch}"
+    else
+      puts forkpoint
+    end
+  }
+
+  add_subcmd(:ancestor) { |*ancestor_args|
+    case ancestor_args.length
+    when 0
+      # Check if main/master is ancestor of HEAD
+      base = %w[main master].find { |b| system("git rev-parse --verify #{b} >/dev/null 2>&1") }
+      unless base
+        puts "Cannot find main or master branch"
+        next
+      end
+      ancestor = base
+      descendant = 'HEAD'
+    when 1
+      # Check if arg is ancestor of HEAD
+      ancestor = ancestor_args[0]
+      descendant = 'HEAD'
+    else
+      ancestor, descendant = ancestor_args[0..1]
+    end
 
-hiiro.run
+    if system("git merge-base --is-ancestor #{ancestor} #{descendant}")
+      puts "Yes, #{ancestor} is an ancestor of #{descendant}"
+    else
+      puts "No, #{ancestor} is NOT an ancestor of #{descendant}"
+    end
+  }
+end