hiiro 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e725d64b462fad99b912e4c4772f62601362a0bd1f16eb8949cfb6d22c914e
-  data.tar.gz: da6b9e03278b930b82cb730e4fc564d7cc6370614475b8fb784632e1ae2b92c9
+  metadata.gz: b4e36b4e41c8423664f340bf38dc96796bb459a9edb161b4c2e937837504bb23
+  data.tar.gz: c4374d147f3ddb4620349697d14701e0c50c0e3ea74034aa0f9cad6eeae162c9
 SHA512:
-  metadata.gz: 16ae1c908d049742e950cc6b7ee7a90c2c80efb44fb289050ea6dc9589d7ae9f955aea1fe68a5eb24daa389bbf1da82c2422628bb2cbbc68ee7a56a3c6326935
-  data.tar.gz: 8591e60b64c1d924b3653439193d9f28a9381a45fde675759eccf3f8604fcf0f0a869b54b749834b080bb30a02a393456fea7b353e3d5f13a17e9947caffe1fc
+  metadata.gz: 820400fc28e1137fce98dc50687c1aeb4543c9b072bca58419c9de5c133c057601e0a9c8b56ff8f6225c36c3e0531d3039cb0011a7bcb8b1bc64e604f0c2f256
+  data.tar.gz: 0abdd6cde316418cbf24ea129cd9988f59561fd25c14e15ee7e4227f7d6a82be3a098e295a7ccde5a899580124af4e92e0a8bed3531f99c89c521c7c9976cc5c

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+)/
+      puts $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-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.10"
+  VERSION = "0.1.12"
 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,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - Joshua Toyota
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -38,14 +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-project
+- 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
@@ -72,6 +77,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
@@ -86,7 +92,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/bin/h-project

@@ -1,176 +0,0 @@
-#!/usr/bin/env ruby
-load '/Users/unixsuperhero/bin/h'
-
-o = Hiiro.init(*ARGV)
-
-# Helper to start or attach to a tmux session
-def start_tmux_session(session_name)
-  session_name = session_name.to_s
-
-  unless system('tmux', 'has-session', '-t', session_name)
-    system('tmux', 'new', '-d', '-A', '-s', session_name)
-  end
-
-  if ENV['TMUX']
-    system('tmux', 'switchc', '-t', session_name)
-  elsif ENV['NVIM']
-    puts "Can't attach to tmux inside a vim terminal"
-  else
-    system('tmux', 'new', '-A', '-s', session_name)
-  end
-end
-
-# Get project directories from ~/proj/
-def project_dirs
-  Dir.glob(File.join(Dir.home, 'proj', '*/')).map { |path|
-    [File.basename(path), path]
-  }.to_h
-end
-
-# Get projects from config file
-def projects_from_config
-  projects_file = File.join(Dir.home, '.config/hiiro', 'projects.yml')
-
-  return {} unless File.exist?(projects_file)
-
-  require 'yaml'
-  YAML.safe_load_file(projects_file)
-end
-
-# === OPEN PROJECT (default) ===
-
-o.add_subcmd(:open) { |project_name|
-  re = /#{project_name}/i
-
-  conf_matches = projects_from_config.select { |k, v| k.match?(re) }
-  dir_matches = project_dirs.select { |proj, path| proj.match?(re) }
-
-  matches = dir_matches.merge(conf_matches)
-  if matches.count > 1
-    matches = matches.select { |name, path| name == project_name }
-  end
-
-  case matches.count
-  when 0
-    name = 'proj'
-    path = File.join(Dir.home, 'proj')
-
-    unless Dir.exist?(path)
-      puts "Error: #{path.inspect} does not exist"
-      exit 1
-    end
-
-    puts "changing dir: #{path}"
-    Dir.chdir(path)
-
-    start_tmux_session(name)
-  when 1
-    name, path = matches.first
-
-    puts "changing dir: #{path}"
-    Dir.chdir(path)
-
-    start_tmux_session(name)
-  when (2..)
-    puts "ERROR: Multiple matches found"
-    puts
-    puts "Matches:"
-    matches.each { |name, path|
-      puts format("  %s: %s", name, path)
-    }
-  end
-}
-
-# === LIST PROJECTS ===
-
-o.add_subcmd(:list) { |*args|
-  dirs = project_dirs
-  conf = projects_from_config
-
-  all_projects = dirs.merge(conf)
-
-  puts "Projects:"
-  puts
-  all_projects.keys.sort.each do |name|
-    path = all_projects[name]
-    source = conf.key?(name) ? '[config]' : '[dir]'
-    puts format("  %-12s %-8s %s", name, source, path)
-  end
-}
-
-o.add_subcmd(:ls) { |*args|
-  o.run_subcmd(:list, *args)
-}
-
-# === SHOW CONFIG FILE ===
-
-o.add_subcmd(:config) { |*args|
-  projects_file = File.join(Dir.home, '.config/hiiro', 'projects.yml')
-
-  if File.exist?(projects_file)
-    puts File.read(projects_file)
-  else
-    puts "No config file found at: #{projects_file}"
-    puts
-    puts "Create it with YAML format:"
-    puts "  project_name: /path/to/project"
-  end
-}
-
-# === EDIT CONFIG FILE ===
-
-o.add_subcmd(:edit) { |*args|
-  projects_file = File.join(Dir.home, '.config/hiiro', 'projects.yml')
-  editor = ENV['EDITOR'] || 'vim'
-
-  # Create config dir if needed
-  config_dir = File.dirname(projects_file)
-  Dir.mkdir(config_dir) unless Dir.exist?(config_dir)
-
-  # Create empty file if it doesn't exist
-  unless File.exist?(projects_file)
-    File.write(projects_file, "# Project aliases\n# project_name: /path/to/project\n")
-  end
-
-  exec(editor, projects_file)
-}
-
-# === HELP ===
-
-o.add_subcmd(:help) { |*args|
-  puts <<~HELP
-    h-project - Project directory and tmux session manager
-
-    USAGE:
-      h-project <project_name>        Open project (fuzzy match) and start tmux session
-      h-project open <project_name>   Same as above
-      h-project list                  List all known projects
-      h-project ls                    Alias for list
-      h-project config                Show config file contents
-      h-project edit                  Edit config file
-
-    SOURCES:
-      Projects are discovered from two sources:
-      1. Directories in ~/proj/
-      2. Entries in ~/.config/hiiro/projects.yml
-
-    CONFIG FORMAT (projects.yml):
-      project_name: /path/to/project
-      another: /some/other/path
-
-    MATCHING:
-      Project names are matched using regex (case insensitive).
-      If multiple matches are found, an exact match is preferred.
-      If still ambiguous, all matches are displayed.
-  HELP
-}
-
-# === DEFAULT SUBCOMMAND ===
-
-o.default_subcommand(:open)
-
-if o.runnable?
-  o.run
-else
-  o.run_subcmd(:help)
-end