hiiro 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e5e7b4d29d69fc56951a3c02b75beae96bcddf607d9613876a0143f8135c537
-  data.tar.gz: 1cd80407b65565cc30d3b76689bd7ebcb444b977cfe38ae757e6d4d1a8db8018
+  metadata.gz: c231fe73a649821cd62ad3bfafaf3a1176891fb6b37fa8a95d7e3a50499553ab
+  data.tar.gz: cc0759a2304557485168249934b108199dce624e972bd5dc4a8663cec283a60c
 SHA512:
-  metadata.gz: ce3bfcdbdadbb9b1fc87b2fc1831cca204999311922a34ee8327dad2aa07171fee6389372200a625d0b6bfe68e1de7f46f55112daf985f60b1e677bd26e08bab
-  data.tar.gz: 57fd1556a68d488e2f2b6b7d72b5052bf63c2afc1640331ac0faceaa74c34d13f3487427302a8891ad66f0c2afbf392ebc492b158620f710caa536ab49aef311
+  metadata.gz: db1cb32fc6c26d31268a845569400fb833509a5289c30b481fcc6a1e6ad0857a98eb837cbb1f1e9c957f45c8132703553d5ea593f60d93ac8bb88a53256205bb
+  data.tar.gz: 32a64ec1dc0acdbd91d2e823c20b65ebb56749b8988531e76efa7d5cd90de0e9ca918f5d1c68377b8632780f6beacf086472e13394c2b106a7f08d1a60080367

data/bin/h-branch

@@ -0,0 +1,213 @@
+#!/usr/bin/env ruby
+
+require "hiiro"
+require "fileutils"
+require "yaml"
+
+Hiiro.load_env
+hiiro = Hiiro.init(*ARGV, plugins: [Task])
+
+class BranchManager
+  attr_reader :hiiro
+
+  def initialize(hiiro)
+    @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
+      puts "ERROR: Not in a git repository"
+      return false
+    end
+
+    entry = build_entry(branch_name)
+    unless entry[:task]
+      puts "WARNING: Not in a task session, saving without task info"
+    end
+
+    data = load_data
+    data['branches'] ||= []
+
+    # Check if this branch is already recorded for this task
+    existing = data['branches'].find do |b|
+      b['name'] == branch_name && b['task'] == entry[:task]
+    end
+
+    if existing
+      # Update existing entry
+      existing.merge!(entry.transform_keys(&:to_s))
+      existing['updated_at'] = Time.now.iso8601
+      puts "Updated branch '#{branch_name}' for task '#{entry[:task]}'"
+    else
+      # Add new entry
+      data['branches'] << entry.transform_keys(&:to_s).merge('created_at' => Time.now.iso8601)
+      puts "Saved branch '#{branch_name}' for task '#{entry[:task]}'"
+    end
+
+    save_data(data)
+    show_entry(entry)
+    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
+      puts "ERROR: Not in a git repository"
+      return false
+    end
+
+    entry = build_entry(branch_name)
+    puts "Current branch info:"
+    puts
+    show_entry(entry)
+  end
+
+  private
+
+  def current_branch
+    branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+    branch.empty? ? nil : branch
+  end
+
+  def build_entry(branch_name)
+    task_info = hiiro.task_manager.send(:current_task)
+    tmux_info = capture_tmux_info
+
+    {
+      name: branch_name,
+      worktree: task_info&.[](:tree),
+      task: task_info&.[](:task),
+      tmux: tmux_info
+    }
+  end
+
+  def capture_tmux_info
+    return nil unless ENV['TMUX']
+
+    {
+      'session' => `tmux display-message -p '#S'`.strip,
+      'window' => `tmux display-message -p '#W'`.strip,
+      'pane' => ENV['TMUX_PANE']
+    }
+  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)'}"
+    puts "  Worktree: #{entry[:worktree] || '(none)'}"
+    if entry[:tmux]
+      puts "  Tmux session: #{entry[:tmux]['session']}"
+      puts "  Tmux window: #{entry[:tmux]['window']}"
+      puts "  Tmux pane: #{entry[:tmux]['pane']}"
+    end
+  end
+
+  def data_file
+    File.join(Dir.home, '.config', 'hiiro', 'branches.yml')
+  end
+
+  def load_data
+    return {} unless File.exist?(data_file)
+    YAML.safe_load_file(data_file) || {}
+  end
+
+  def save_data(data)
+    FileUtils.mkdir_p(File.dirname(data_file))
+    File.write(data_file, YAML.dump(data))
+  end
+end
+
+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_default { manager.help }
+
+hiiro.run

data/bin/h-link

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'fileutils'
+require 'time'
+
+require "hiiro"
+
+LINKS_FILE = File.join(Dir.home, '.config/hiiro/links.yml')
+
+o = Hiiro.init(*ARGV, plugins: [Tmux, Pins], links_file: LINKS_FILE)
+
+def ensure_links_file
+  dir = File.dirname(LINKS_FILE)
+  FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+  File.write(LINKS_FILE, [].to_yaml) unless File.exist?(LINKS_FILE)
+end
+
+def load_links
+  ensure_links_file
+  YAML.load_file(LINKS_FILE) || []
+end
+
+def save_links(links)
+  ensure_links_file
+  File.write(LINKS_FILE, links.to_yaml)
+end
+
+def find_link_by_ref(ref, links)
+  if ref =~ /^\d+$/
+    idx = ref.to_i - 1
+    return [idx, links[idx]] if idx >= 0 && idx < links.length
+  else
+    links.each_with_index do |link, idx|
+      return [idx, link] if link['shorthand'] == ref
+    end
+  end
+  [nil, nil]
+end
+
+o.add_subcmd(:save) do |*args|
+  if args.empty?
+    puts "Usage: h link save <url> [description...]"
+    exit 1
+  end
+
+  url = args.shift
+  description = args.join(' ')
+
+  links = load_links
+  links << {
+    'url' => url,
+    'description' => description,
+    'shorthand' => nil,
+    'created_at' => Time.now.iso8601
+  }
+  save_links(links)
+
+  puts "Saved link ##{links.length}: #{url}"
+end
+
+o.add_subcmd(:ls) do |*args|
+  links = load_links
+  if links.empty?
+    puts "No links saved."
+  else
+    links.each_with_index do |link, idx|
+      num = (idx + 1).to_s.rjust(3)
+      shorthand = link['shorthand'] ? " [#{link['shorthand']}]" : ""
+      desc = link['description'].to_s.empty? ? "" : " - #{link['description']}"
+      puts "#{num}.#{shorthand} #{link['url']}#{desc}"
+    end
+  end
+end
+
+o.add_subcmd(:list) do |*args|
+  o.run_subcmd(:ls, *args)
+end
+
+o.add_subcmd(:search) do |*args|
+  if args.empty?
+    puts "Usage: h link search <term> [term...]"
+    exit 1
+  end
+
+  links = load_links
+  terms = args.map(&:downcase)
+
+  matches = links.each_with_index.select do |link, idx|
+    searchable = [
+      link['url'],
+      link['description'],
+      link['shorthand']
+    ].compact.join(' ').downcase
+
+    terms.any? { |term| searchable.include?(term) }
+  end
+
+  if matches.empty?
+    puts "No links found matching: #{args.join(' ')}"
+  else
+    matches.each do |link, idx|
+      num = (idx + 1).to_s.rjust(3)
+      shorthand = link['shorthand'] ? " [#{link['shorthand']}]" : ""
+      desc = link['description'].to_s.empty? ? "" : " - #{link['description']}"
+      puts "#{num}.#{shorthand} #{link['url']}#{desc}"
+    end
+  end
+end
+
+o.add_subcmd(:select) do |*args|
+  links = load_links
+  if links.empty?
+    STDERR.puts "No links saved."
+    exit 1
+  end
+
+  lines = links.each_with_index.map do |link, idx|
+    num = (idx + 1).to_s.rjust(3)
+    desc = link['description'].to_s.empty? ? "" : " - #{link['description']}"
+    "#{num}. #{link['url']}#{desc}"
+  end
+
+  require 'open3'
+  selected, status = Open3.capture2('sk', stdin_data: lines.join("\n"))
+
+  if status.success? && !selected.strip.empty?
+    if selected =~ /^\s*(\d+)\.\s+(\S+)/
+      print $2
+    end
+  end
+end
+
+o.add_subcmd(:edit) do |*args|
+  if args.empty?
+    puts "Usage: h link edit <number|shorthand>"
+    exit 1
+  end
+
+  links = load_links
+  idx, link = find_link_by_ref(args.first, links)
+
+  if link.nil?
+    puts "Link not found: #{args.first}"
+    exit 1
+  end
+
+  require 'tempfile'
+  tmpfile = Tempfile.new(['link-edit-', '.yml'])
+  tmpfile.write(link.to_yaml)
+  tmpfile.close
+
+  system(ENV['EDITOR'] || 'vim', tmpfile.path)
+
+  updated = YAML.load_file(tmpfile.path)
+  tmpfile.unlink
+
+  links[idx] = updated
+  save_links(links)
+
+  puts "Updated link ##{idx + 1}"
+end
+
+o.add_subcmd(:open) do |*args|
+  if args.empty?
+    puts "Usage: h link open <number|shorthand>"
+    exit 1
+  end
+
+  links = load_links
+  idx, link = find_link_by_ref(args.first, links)
+
+  if link.nil?
+    puts "Link not found: #{args.first}"
+    exit 1
+  end
+
+  system('open', link['url'])
+end
+
+o.add_subcmd(:path) do |*args|
+  print LINKS_FILE
+end
+
+begin
+  o.run
+rescue => e
+  require 'pry'
+  binding.pry
+end

data/bin/h-pr

@@ -0,0 +1,257 @@
+#!/usr/bin/env ruby
+
+require "hiiro"
+require "fileutils"
+require "yaml"
+require "json"
+
+Hiiro.load_env
+hiiro = Hiiro.init(*ARGV, plugins: [Task])
+
+class PRManager
+  attr_reader :hiiro
+
+  def initialize(hiiro)
+    @hiiro = hiiro
+  end
+
+  def help
+    puts "Usage: h pr <subcommand> [args]"
+    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"
+  end
+
+  def save(pr_number = nil)
+    pr_info = fetch_pr_info(pr_number)
+    unless pr_info
+      puts "ERROR: Could not find PR"
+      puts "Make sure you have the gh CLI installed and authenticated."
+      return false
+    end
+
+    entry = build_entry(pr_info)
+    unless entry[:task]
+      puts "WARNING: Not in a task session, saving without task info"
+    end
+
+    data = load_data
+    data['prs'] ||= []
+
+    # Check if this PR is already recorded for this task
+    existing = data['prs'].find do |p|
+      p['number'] == pr_info['number'] && p['task'] == entry[:task]
+    end
+
+    if existing
+      # Update existing entry
+      existing.merge!(entry.transform_keys(&:to_s))
+      existing['updated_at'] = Time.now.iso8601
+      puts "Updated PR ##{pr_info['number']} for task '#{entry[:task]}'"
+    else
+      # Add new entry
+      data['prs'] << entry.transform_keys(&:to_s).merge('created_at' => Time.now.iso8601)
+      puts "Saved PR ##{pr_info['number']} for task '#{entry[:task]}'"
+    end
+
+    save_data(data)
+    show_entry(entry)
+    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
+      puts "No PR found for current branch."
+      puts "Create one with 'gh pr create' or specify a PR number."
+      return false
+    end
+
+    entry = build_entry(pr_info)
+    puts "Current PR info:"
+    puts
+    show_entry(entry)
+  end
+
+  def open(pr_number = nil)
+    if pr_number
+      system('gh', 'pr', 'view', pr_number.to_s, '--web')
+    else
+      system('gh', 'pr', 'view', '--web')
+    end
+  end
+
+  def view(pr_number = nil)
+    if pr_number
+      system('gh', 'pr', 'view', pr_number.to_s)
+    else
+      system('gh', 'pr', 'view')
+    end
+  end
+
+  private
+
+  def fetch_pr_info(pr_number = nil)
+    cmd = if pr_number
+      ['gh', 'pr', 'view', pr_number.to_s, '--json', 'number,title,url,headRefName,state']
+    else
+      ['gh', 'pr', 'view', '--json', 'number,title,url,headRefName,state']
+    end
+
+    output = `#{cmd.join(' ')} 2>/dev/null`
+    return nil if output.empty?
+
+    JSON.parse(output)
+  rescue JSON::ParserError
+    nil
+  end
+
+  def build_entry(pr_info)
+    task_info = hiiro.task_manager.send(:current_task)
+    tmux_info = capture_tmux_info
+
+    {
+      number: pr_info['number'],
+      title: pr_info['title'],
+      url: pr_info['url'],
+      branch: pr_info['headRefName'],
+      state: pr_info['state'],
+      worktree: task_info&.[](:tree),
+      task: task_info&.[](:task),
+      tmux: tmux_info
+    }
+  end
+
+  def capture_tmux_info
+    return nil unless ENV['TMUX']
+
+    {
+      'session' => `tmux display-message -p '#S'`.strip,
+      'window' => `tmux display-message -p '#W'`.strip,
+      'pane' => ENV['TMUX_PANE']
+    }
+  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']}"
+    lines << "   Branch: #{entry['branch']}"
+    lines << "   State: #{entry['state']}"
+    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 << "   URL: #{entry['url']}"
+    lines.join("\n")
+  end
+
+  def show_entry(entry)
+    puts "  PR: ##{entry[:number]}"
+    puts "  Title: #{entry[:title]}"
+    puts "  Branch: #{entry[:branch]}"
+    puts "  State: #{entry[:state]}"
+    puts "  URL: #{entry[:url]}"
+    puts "  Task: #{entry[:task] || '(none)'}"
+    puts "  Worktree: #{entry[:worktree] || '(none)'}"
+    if entry[:tmux]
+      puts "  Tmux session: #{entry[:tmux]['session']}"
+      puts "  Tmux window: #{entry[:tmux]['window']}"
+      puts "  Tmux pane: #{entry[:tmux]['pane']}"
+    end
+  end
+
+  def data_file
+    File.join(Dir.home, '.config', 'hiiro', 'prs.yml')
+  end
+
+  def load_data
+    return {} unless File.exist?(data_file)
+    YAML.safe_load_file(data_file) || {}
+  end
+
+  def save_data(data)
+    FileUtils.mkdir_p(File.dirname(data_file))
+    File.write(data_file, YAML.dump(data))
+  end
+end
+
+manager = PRManager.new(hiiro)
+
+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) }
+
+hiiro.add_default { manager.help }
+
+hiiro.run

data/bin/h-session

@@ -1,26 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'hiiro'
-require 'pry'
-require 'rspec'
-
-# $> h session
-#
-#  Subcommand required!
-#
-#  Possible subcommands:
-#    pin       (subcommand)  /Users/unixsuperhero/.config/hiiro/plugins/pins.rb:12
-#    edit      (subcommand)  /Users/unixsuperhero/.rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/hiiro-0.1.8/lib/hiiro.rb:14
-#    ses       (subcommand)  /Users/unixsuperhero/bin/h-session:99
-#    ls        (subcommand)  /Users/unixsuperhero/bin/h-session:111
-#    new       (subcommand)  /Users/unixsuperhero/bin/h-session:115
-#    kill      (subcommand)  /Users/unixsuperhero/bin/h-session:119
-#    attach    (subcommand)  /Users/unixsuperhero/bin/h-session:123
-#    rename    (subcommand)  /Users/unixsuperhero/bin/h-session:127
-#    switch    (subcommand)  /Users/unixsuperhero/bin/h-session:131
-#    detach    (subcommand)  /Users/unixsuperhero/bin/h-session:135
-#    has       (subcommand)  /Users/unixsuperhero/bin/h-session:139
-#    info      (subcommand)  /Users/unixsuperhero/bin/h-session:143
+load File.join(Dir.home, 'bin', 'h')
 
 o = Hiiro.init(*ARGV, plugins: [Pins])
 

data/bin/h-subtask

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+# Shorthand for `h task subtask`
+
+require "hiiro"
+require "fileutils"
+require "yaml"
+
+Hiiro.load_env
+hiiro = Hiiro.init(*ARGV, plugins: [Tmux, Task])
+
+tasks = hiiro.task_manager
+
+hiiro.add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }
+hiiro.add_subcmd(:ls) { tasks.list_subtasks }
+hiiro.add_subcmd(:new) { |subtask_name| tasks.new_subtask(subtask_name) }
+hiiro.add_subcmd(:switch) { |subtask_name| tasks.switch_subtask(subtask_name) }
+
+hiiro.add_default { tasks.subtask_help }
+
+hiiro.run

data/bin/h-wtree

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'hiiro'
+
+Hiiro.run(*ARGV) do |h|
+  h.add_subcmd(:ls)  { |*args| system('git', 'worktree', 'list', *args) }
+  h.add_subcmd(:list)  { |*args| h.run_subcmd(:ls, *args) }
+  h.add_subcmd(:add)  { |*args| system('git', 'worktree', 'add', *args) }
+  h.add_subcmd(:lock)  { |*args| system('git', 'worktree', 'lock', *args) }
+  h.add_subcmd(:move)  { |*args| system('git', 'worktree', 'move', *args) }
+  h.add_subcmd(:prune)  { |*args| system('git', 'worktree', 'prune', *args) }
+  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) }
+end
+

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.9"
+  VERSION = "0.1.11"
 end

data/lib/hiiro.rb

@@ -19,6 +19,12 @@ class Hiiro
     end
   end
 
+  def self.run(*args, plugins: [], logging: false, **values, &block)
+    hiiro = init(*args, plugins:,logging:,**values, &block)
+
+    hiiro.run
+  end
+
   def self.load_env
     Config.plugin_files.each do |plugin_file|
       require plugin_file
@@ -82,6 +88,11 @@ class Hiiro
   end
   alias add_subcmd add_subcommand
 
+  def run_subcommand(name, *args)
+    runners.run_subcommand(name, *args)
+  end
+  alias run_subcmd run_subcommand
+
   def full_name
     runner&.full_name || [bin_name, subcmd].join(?-)
   end
@@ -226,6 +237,12 @@ class Hiiro
       @subcommands[name] = Subcommand.new(bin_name, name, handler, values)
     end
 
+    def run_subcommand(name, *args)
+      cmd = subcommands[name]
+
+      cmd&.run(*args)
+    end
+
     def exact_runner
       all_runners.find { |r| r.exact_match?(subcmd) }
     end

data/plugins/task.rb

@@ -26,6 +26,7 @@ module Task
         status: ->(*sargs) { tasks.status },
         save: ->(*sargs) { tasks.save_current },
         stop: ->(*sargs) { tasks.stop_current },
+        subtask: ->(*sargs) { tasks.handle_subtask(*sargs) },
       }
 
       case args
@@ -51,6 +52,14 @@ module Task
         tasks.stop_current
       in ['stop', task_name]
         tasks.stop_task(task_name)
+      in ['subtask']
+        tasks.subtask_help
+      in ['subtask', 'ls']
+        tasks.list_subtasks
+      in ['subtask', 'new', subtask_name]
+        tasks.new_subtask(subtask_name)
+      in ['subtask', 'switch', subtask_name]
+        tasks.switch_subtask(subtask_name)
       in [subcmd, *sargs]
         match = runner_map.keys.find { |full_subcmd| full_subcmd.to_s.start_with?(subcmd) }
 
@@ -94,6 +103,7 @@ module Task
       puts "  save                  Save current tmux session info for this task"
       puts "  status, st            Show current task status"
       puts "  stop                  Stop working on current task (worktree becomes available)"
+      puts "  subtask <subcmd>      Manage subtasks (ls, new, switch)"
     end
 
     # List all worktrees and their active tasks
@@ -363,6 +373,183 @@ module Task
       true
     end
 
+    # Subtask management
+    def subtask_help
+      puts "Usage: h task subtask <subcommand> [args]"
+      puts "       h subtask <subcommand> [args]"
+      puts
+      puts "Subcommands:"
+      puts "  ls                    List subtasks for current task"
+      puts "  new SUBTASK_NAME      Start a new subtask (creates worktree and session)"
+      puts "  switch SUBTASK_NAME   Switch to subtask's tmux session"
+    end
+
+    def handle_subtask(*args)
+      case args
+      in []
+        subtask_help
+      in ['ls']
+        list_subtasks
+      in ['new', subtask_name]
+        new_subtask(subtask_name)
+      in ['switch', subtask_name]
+        switch_subtask(subtask_name)
+      else
+        puts "Unknown subtask command: #{args.inspect}"
+        subtask_help
+      end
+    end
+
+    def list_subtasks
+      current = current_task
+      unless current
+        puts "ERROR: Not currently in a task session"
+        return false
+      end
+
+      parent_task = current[:task]
+      subtasks = subtasks_for_task(parent_task)
+
+      if subtasks.empty?
+        puts "No subtasks for task '#{parent_task}'."
+        puts
+        puts "Create one with 'h subtask new SUBTASK_NAME'"
+        return
+      end
+
+      puts "Subtasks for '#{parent_task}':"
+      puts
+      subtasks.each do |subtask|
+        marker = subtask['active'] ? "*" : " "
+        puts format("%s %-25s  tree: %-15s  created: %s",
+          marker,
+          subtask['name'],
+          subtask['worktree'] || '(none)',
+          subtask['created_at']&.split('T')&.first || '?'
+        )
+      end
+    end
+
+    def new_subtask(subtask_name)
+      current = current_task
+      unless current
+        puts "ERROR: Not currently in a task session"
+        puts "Use 'h task start TASK_NAME' first"
+        return false
+      end
+
+      parent_task = current[:task]
+      full_subtask_name = "#{parent_task}/#{subtask_name}"
+
+      # Check if subtask already exists
+      existing = subtasks_for_task(parent_task).find { |s| s['name'] == subtask_name }
+      if existing
+        puts "Subtask '#{subtask_name}' already exists for task '#{parent_task}'"
+        puts "Switching to existing session..."
+        switch_subtask(subtask_name)
+        return true
+      end
+
+      # Create new worktree for subtask
+      puts "Creating new worktree for subtask '#{subtask_name}'..."
+      new_path = File.join(Dir.home, 'work', full_subtask_name)
+
+      result = system('git', '-C', main_repo_path, 'worktree', 'add', '--detach', new_path)
+      unless result
+        puts "ERROR: Failed to create worktree"
+        return false
+      end
+      clear_worktree_cache
+
+      # Associate subtask with tree
+      assign_task_to_tree(full_subtask_name, full_subtask_name)
+
+      # Record subtask in parent's metadata
+      add_subtask_to_task(parent_task, {
+        'name' => subtask_name,
+        'worktree' => full_subtask_name,
+        'session' => full_subtask_name,
+        'created_at' => Time.now.iso8601,
+        'active' => true
+      })
+
+      # Create/switch to tmux session
+      Dir.chdir(new_path)
+      hiiro.start_tmux_session(full_subtask_name)
+
+      puts "Started subtask '#{subtask_name}' for task '#{parent_task}'"
+      true
+    end
+
+    def switch_subtask(subtask_name)
+      current = current_task
+      unless current
+        puts "ERROR: Not currently in a task session"
+        puts "Use 'h task start TASK_NAME' first"
+        return false
+      end
+
+      parent_task = current[:task]
+      # Handle if we're in a subtask - get the parent
+      if parent_task.include?('/')
+        parent_task = parent_task.split('/').first
+      end
+
+      subtask = find_subtask(parent_task, subtask_name)
+      unless subtask
+        puts "Subtask '#{subtask_name}' not found for task '#{parent_task}'"
+        puts
+        list_subtasks
+        return false
+      end
+
+      session_name = subtask['session'] || "#{parent_task}/#{subtask_name}"
+      tree_name = subtask['worktree'] || session_name
+
+      # Check if session exists
+      session_exists = system('tmux', 'has-session', '-t', session_name, err: File::NULL)
+
+      if session_exists
+        hiiro.start_tmux_session(session_name)
+      else
+        # Create new session in the worktree path
+        path = tree_path(tree_name)
+        if Dir.exist?(path)
+          Dir.chdir(path)
+          hiiro.start_tmux_session(session_name)
+        else
+          puts "ERROR: Worktree path '#{path}' does not exist"
+          return false
+        end
+      end
+
+      puts "Switched to subtask '#{subtask_name}'"
+      true
+    end
+
+    private
+
+    def subtasks_for_task(task_name)
+      meta = task_metadata(task_name)
+      return [] unless meta
+      meta['subtasks'] || []
+    end
+
+    def find_subtask(parent_task, subtask_name)
+      subtasks = subtasks_for_task(parent_task)
+      subtasks.find { |s| s['name'].start_with?(subtask_name) }
+    end
+
+    def add_subtask_to_task(parent_task, subtask_data)
+      meta = task_metadata(parent_task) || {}
+      meta['subtasks'] ||= []
+      meta['subtasks'] << subtask_data
+      FileUtils.mkdir_p(task_dir)
+      File.write(task_metadata_file(parent_task), YAML.dump(meta))
+    end
+
+    public
+
     def list_configured_apps
       if apps_config.any?
         puts "Configured apps (#{apps_config_file}):"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Joshua Toyota
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-25 00:00:00.000000000 Z
+date: 2026-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -39,13 +39,18 @@ files:
 - README.md
 - Rakefile
 - bin/h
+- bin/h-branch
 - bin/h-buffer
+- bin/h-link
 - bin/h-pane
 - bin/h-plugin
+- bin/h-pr
 - bin/h-session
+- bin/h-subtask
 - bin/h-task
 - bin/h-video
 - bin/h-window
+- bin/h-wtree
 - docs/README.md
 - docs/h-buffer.md
 - docs/h-pane.md