hiiro 0.1.265 → 0.1.266

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc901c630e69f036ba17ebb63bf913618ea825ce6746d5db20df55177fd0b9ba
-  data.tar.gz: 29ef84306acd767569975e56c2c44e10868f7490040b94d80d73f20db7ade326
+  metadata.gz: 7eecd997945d2c597a4b6e9c28ec2d8b485871ae91f304695cddeec40414c605
+  data.tar.gz: ccb6d7acb90b1d794c650ddad420d7c113baa9e8819ae2f2ec205e1fec6cf652
 SHA512:
-  metadata.gz: 053fa8e529cb941c97447e0540cbaa2ebb48634a47911627760cd01af2f5f3251d403b69a8296443f33531efcf039bfcba738ee5f02065a475583da1bb8c7a70
-  data.tar.gz: 40073e682ab750f5e5633ea511a500bc2537708aa2abcb392b994cbd30a9c580227058859829f10838669ce5f790693d34473a480d680d11191f6b57227275ab
+  metadata.gz: 0f8a631772992bfc9f61d9a8ea25c16e993459f1792441a963d7e2ff1563b3bcce9ce4bbf213225ebc0eb7e03527be0a316599417b34832b24056e30649e7547
+  data.tar.gz: 78a971962958be80d9936c0606329a54b5a6a4ec6cf4a8185f07d1b0bf3d61c9d504eba8e9bebd6e07627e71feb89ba968ab216e8ace23852fde2200390a7623

data/CHANGELOG.md

@@ -1 +1 @@
-Done. The CHANGELOG.md has been updated with v0.1.265 released today (2026-03-18), with all the unreleased features now captured in that release. An empty Unreleased section remains at the top for future entries.
+Done. CHANGELOG.md updated with v0.1.266 section at the top.

data/bin/h-pane

@@ -107,63 +107,11 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
     end
   }
 
-  add_subcmd(:sw) { |target = nil, *args|
+  add_subcmd(:sw, :switch) { |target = nil, *args|
     target ||= fuzzyfind_from_map(tmux.panes(all: true).name_map)
     tmux.open_session(target) if target
   }
 
-  add_subcmd(:switch) { |name = nil|
-    homes = load_homes.call
-
-    if name.nil?
-      if homes.empty?
-        puts "No home panes configured. Use 'h pane home add <name> <session> [path]'"
-        next
-      end
-      display_map = homes.each_with_object({}) do |(n, cfg), h|
-        label = "#{n}  [#{cfg['session']}#{cfg['path'] ? "  #{cfg['path']}" : ''}]"
-        h[label] = n
-      end
-      name = fuzzyfind_from_map(display_map)
-      next unless name
-    end
-
-    cfg = homes[name]
-    unless cfg
-      matched = homes.keys.select { |k| k.start_with?(name) }
-      case matched.size
-      when 1
-        name = matched.first
-        cfg = homes[name]
-      when 0
-        puts "Home pane '#{name}' not found"
-        next
-      else
-        puts "Ambiguous home pane '#{name}': #{matched.join(', ')}"
-        next
-      end
-    end
-
-    session = cfg['session']
-    path = cfg['path']
-
-    if !tmux.session_exists?(session)
-      tmux.new_session(session, detached: true, start_directory: path, window_name: name)
-    else
-      window_names = `tmux list-windows -t #{session.shellescape} -F '\#{window_name}' 2>/dev/null`.lines(chomp: true)
-      unless window_names.include?(name)
-        tmux.new_window(name: name, target: session, start_directory: path)
-      end
-    end
-
-    target = "#{session}:#{name}"
-    if tmux.in_tmux?
-      system('tmux', 'switch-client', '-t', target)
-    else
-      system('tmux', 'attach-session', '-t', target)
-    end
-  }
-
   add_subcmd(:home) { |*args|
     run_child(:home) do |h|
       h.add_subcmd(:ls) {
@@ -204,6 +152,59 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
           puts "Home pane '#{name}' not found"
         end
       }
+
+      h.add_subcmd(:switch) { |name = nil|
+        homes = load_homes.call
+
+        if name.nil?
+          if homes.empty?
+            puts "No home panes configured. Use 'h pane home add <name> <session> [path]'"
+            next
+          end
+          display_map = homes.each_with_object({}) do |(n, cfg), map|
+            label = "#{n}  [#{cfg['session']}#{cfg['path'] ? "  #{cfg['path']}" : ''}]"
+            map[label] = n
+          end
+          name = fuzzyfind_from_map(display_map)
+          next unless name
+        end
+
+        cfg = homes[name]
+        unless cfg
+          matched = homes.keys.select { |k| k.start_with?(name) }
+          case matched.size
+          when 1
+            name = matched.first
+            cfg = homes[name]
+          when 0
+            puts "Home pane '#{name}' not found"
+            next
+          else
+            puts "Ambiguous home pane '#{name}': #{matched.join(', ')}"
+            next
+          end
+        end
+
+        session = cfg['session']
+        path = cfg['path']
+
+        if !tmux.session_exists?(session)
+          tmux.new_session(session, detached: true, start_directory: path, window_name: name)
+        else
+          window_names = `tmux list-windows -t #{session.shellescape} -F '\#{window_name}' 2>/dev/null`.lines(chomp: true)
+          unless window_names.include?(name)
+            dir = path || tmux.find_session(session)&.path
+            tmux.new_window(name: name, target: session, start_directory: dir)
+          end
+        end
+
+        target = "#{session}:#{name}"
+        if tmux.in_tmux?
+          system('tmux', 'switch-client', '-t', target)
+        else
+          system('tmux', 'attach-session', '-t', target)
+        end
+      }
     end
   }
 

data/bin/h-pr

@@ -1863,6 +1863,115 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
     end
   end
 
+  add_subcmd(:dep) do |*args|
+    run_child(:dep) do |h|
+      h.add_subcmd(:add) { |ref = nil, *dep_refs|
+        if ref.nil? || dep_refs.empty?
+          puts "Usage: h pr dep add <pr> <dep1> [dep2 ...]"
+          next
+        end
+
+        pr_number = resolve_pr.call(ref)
+        next unless pr_number
+
+        dep_numbers = dep_refs.map { |r| resolve_pr.call(r) }.compact
+        if dep_numbers.empty?
+          puts "No valid dependency PRs resolved"
+          next
+        end
+
+        pinned = pinned_manager.load_pinned
+        pr = pinned.find { |p| p.number.to_s == pr_number.to_s }
+        unless pr
+          puts "PR ##{pr_number} is not tracked — pin it first with: h pr track #{pr_number}"
+          next
+        end
+
+        pr.depends_on = (Array(pr.depends_on) + dep_numbers.map(&:to_i)).uniq.sort
+        pinned_manager.save_pinned(pinned)
+        puts "PR ##{pr_number} now depends on: #{pr.depends_on.map { |n| "##{n}" }.join(', ')}"
+      }
+
+      h.add_subcmd(:rm) { |ref = nil, *dep_refs|
+        if ref.nil?
+          puts "Usage: h pr dep rm <pr> [dep1 dep2 ...]  (omit deps to clear all)"
+          next
+        end
+
+        pr_number = resolve_pr.call(ref)
+        next unless pr_number
+
+        pinned = pinned_manager.load_pinned
+        pr = pinned.find { |p| p.number.to_s == pr_number.to_s }
+        unless pr
+          puts "PR ##{pr_number} not in tracked list"
+          next
+        end
+
+        if dep_refs.empty?
+          pr.depends_on = nil
+          puts "Cleared all dependencies from ##{pr_number}"
+        else
+          dep_numbers = dep_refs.map { |r| resolve_pr.call(r) }.compact.map(&:to_i)
+          pr.depends_on = (Array(pr.depends_on) - dep_numbers).then { |d| d.empty? ? nil : d }
+          puts "Removed dep(s) #{dep_numbers.map { |n| "##{n}" }.join(', ')} from ##{pr_number}"
+          puts "  Remaining: #{Array(pr.depends_on).map { |n| "##{n}" }.join(', ').then { |s| s.empty? ? '(none)' : s }}"
+        end
+
+        pinned_manager.save_pinned(pinned)
+      }
+
+      h.add_subcmd(:ls) { |ref = nil|
+        pinned = pinned_manager.load_pinned
+
+        if ref
+          pr_number = resolve_pr.call(ref)
+          next unless pr_number
+          pr = pinned.find { |p| p.number.to_s == pr_number.to_s }
+          unless pr
+            puts "PR ##{pr_number} not in tracked list"
+            next
+          end
+          deps = Array(pr.depends_on)
+          if deps.empty?
+            puts "##{pr_number} has no dependencies"
+          else
+            puts "##{pr_number}: #{pr.title}"
+            puts "  depends on:"
+            deps.each do |dep_num|
+              dep = pinned.find { |p| p.number == dep_num }
+              label = dep ? "  ##{dep_num}: #{dep.title}" : "  ##{dep_num} (not tracked)"
+              puts label
+            end
+          end
+        else
+          with_deps = pinned.select { |p| Array(p.depends_on).any? }
+          if with_deps.empty?
+            puts "No dependency relationships configured."
+            puts "Use: h pr dep add <pr> <dep1> [dep2 ...]"
+          else
+            with_deps.each do |pr|
+              puts "##{pr.number}: #{pr.title}"
+              Array(pr.depends_on).each do |dep_num|
+                dep = pinned.find { |p| p.number == dep_num }
+                label = dep ? "  └─ ##{dep_num}: #{dep.title}" : "  └─ ##{dep_num} (not tracked)"
+                puts label
+              end
+            end
+          end
+        end
+      }
+
+      h.add_subcmd(:config) {
+        puts Hiiro::Git::Pr::PINNED_FILE
+      }
+
+      h.add_subcmd(:edit) {
+        edit_files Hiiro::Git::Pr::PINNED_FILE
+      }
+    end
+  end
+
   add_subcmd(:config) do |*args|
     make_child do
       add_subcmd(:path) do

data/lib/hiiro/git/pr.rb

@@ -9,7 +9,7 @@ class Hiiro
       attr_accessor :number, :title, :state, :url, :head_branch, :base_branch,
                     :repo, :slot, :is_draft, :mergeable, :review_decision,
                     :checks, :check_runs, :reviews, :last_checked, :pinned_at, :updated_at,
-                    :task, :worktree, :tmux_session, :tags, :assigned, :authored
+                    :task, :worktree, :tmux_session, :tags, :assigned, :authored, :depends_on
 
       # Load all pinned PRs from YAML, returning an array of Pr instances.
       def self.pinned_prs
@@ -58,6 +58,7 @@ class Hiiro
           tags:            hash['tags'],
           assigned:        hash['assigned'],
           authored:        hash['authored'],
+          depends_on:      hash['depends_on'],
         )
       end
 
@@ -163,7 +164,8 @@ class Hiiro
                      repo: nil, slot: nil, is_draft: nil, mergeable: nil, review_decision: nil,
                      checks: nil, check_runs: nil, reviews: nil, last_checked: nil,
                      pinned_at: nil, updated_at: nil,
-                     task: nil, worktree: nil, tmux_session: nil, tags: nil, assigned: nil, authored: nil)
+                     task: nil, worktree: nil, tmux_session: nil, tags: nil, assigned: nil, authored: nil,
+                     depends_on: nil)
         @number          = number
         @title           = title
         @state           = state
@@ -187,6 +189,7 @@ class Hiiro
         @tags            = tags
         @assigned        = assigned
         @authored        = authored
+        @depends_on      = depends_on ? Array(depends_on).map(&:to_i) : nil
       end
 
       def open?        = state&.upcase == 'OPEN'
@@ -233,6 +236,7 @@ class Hiiro
           'tags'                => (Array(tags).empty? ? nil : tags),
           'assigned'            => assigned,
           'authored'            => authored,
+          'depends_on'          => (Array(depends_on).empty? ? nil : depends_on),
         }.compact
       end
 

data/lib/hiiro/queue.rb

@@ -138,12 +138,16 @@ class Hiiro
       # Determine target tmux session and working directory from frontmatter
       target_session = TMUX_SESSION
       working_dir = Dir.pwd
+      tree_root = nil
 
       if prompt_obj
         if prompt_obj.task
           target_session = prompt_obj.session_name
           tree = prompt_obj.task.tree
-          working_dir = tree.path if tree
+          if tree
+            working_dir = tree.path
+            tree_root = tree.path
+          end
         elsif prompt_obj.session
           target_session = prompt_obj.session.name
           working_dir = prompt_obj.session.path || working_dir
@@ -151,6 +155,22 @@ class Hiiro
 
         if prompt_obj.tree
           working_dir = prompt_obj.tree.path
+          tree_root = prompt_obj.tree.path
+        end
+
+        # Resolve app + dir frontmatter on top of whatever tree root we have
+        if prompt_obj.app_name
+          env = Environment.current rescue nil
+          app = env&.find_app(prompt_obj.app_name)
+          if app
+            root = tree_root || git_root_of(working_dir)
+            app_dir = File.join(root, app.relative_path)
+            working_dir = prompt_obj.rel_dir ? File.join(app_dir, prompt_obj.rel_dir) : app_dir
+          else
+            warn "hq: app '#{prompt_obj.app_name}' not found — falling back to tree/session dir"
+          end
+        elsif prompt_obj.rel_dir
+          working_dir = File.join(tree_root || working_dir, prompt_obj.rel_dir)
         end
       end
 
@@ -298,6 +318,11 @@ class Hiiro
       windows.include?(wname)
     end
 
+    def git_root_of(dir)
+      root = `git -C #{Shellwords.shellescape(dir)} rev-parse --show-toplevel 2>/dev/null`.strip
+      root.empty? ? dir : root
+    end
+
     def slugify(text)
       text.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')[0, 60]
     end
@@ -491,17 +516,17 @@ class Hiiro
           elsif args.any?
             content = args.join(' ')
           else
-            # Pre-fill with frontmatter template if task_info or flags require it
-            fm_content = if ti || opts.ignore
-              fm_lines = ["---"]
-              fm_lines << "task_name: #{ti[:task_name]}" if ti&.dig(:task_name)
-              fm_lines << "tree_name: #{ti[:tree_name]}" if ti&.dig(:tree_name)
-              fm_lines << "session_name: #{ti[:session_name]}" if ti&.dig(:session_name)
-              fm_lines << "ignore: true" if opts.ignore
-              fm_lines << "---"
-              fm_lines << ""
-              fm_lines.join("\n")
-            end
+            # Pre-fill with frontmatter template
+            fm_lines = ["---"]
+            fm_lines << "task_name: #{ti[:task_name]}" if ti&.dig(:task_name)
+            fm_lines << "tree_name: #{ti[:tree_name]}" if ti&.dig(:tree_name)
+            fm_lines << "session_name: #{ti[:session_name]}" if ti&.dig(:session_name)
+            fm_lines << "ignore: true" if opts.ignore
+            fm_lines << "# app: <partial-app-name>  (run claude from this app's directory)"
+            fm_lines << "# dir: <relative-path>     (subdir within app or tree root)"
+            fm_lines << "---"
+            fm_lines << ""
+            fm_content = fm_lines.join("\n")
 
             input = InputFile.md_file(hiiro: h, content: fm_content, append: !!fm_content, prefix: 'hq-')
             input.edit
@@ -553,16 +578,15 @@ class Hiiro
           path = File.join(q.queue_dirs[:wip], "#{name}.md")
 
           unless File.exist?(path)
-            # Pre-fill with frontmatter if task_info available
-            if ti
-              fm_lines = ["---"]
-              fm_lines << "task_name: #{ti[:task_name]}" if ti[:task_name]
-              fm_lines << "tree_name: #{ti[:tree_name]}" if ti[:tree_name]
-              fm_lines << "session_name: #{ti[:session_name]}" if ti[:session_name]
-              fm_lines << "---"
-              fm_lines << ""
-              File.write(path, fm_lines.join("\n"))
-            end
+            fm_lines = ["---"]
+            fm_lines << "task_name: #{ti[:task_name]}" if ti&.dig(:task_name)
+            fm_lines << "tree_name: #{ti[:tree_name]}" if ti&.dig(:tree_name)
+            fm_lines << "session_name: #{ti[:session_name]}" if ti&.dig(:session_name)
+            fm_lines << "# app: <partial-app-name>  (run claude from this app's directory)"
+            fm_lines << "# dir: <relative-path>     (subdir within app or tree root)"
+            fm_lines << "---"
+            fm_lines << ""
+            File.write(path, fm_lines.join("\n"))
           end
 
           h.edit_files(path)
@@ -731,6 +755,14 @@ class Hiiro
         doc.front_matter['tree_name']
       end
 
+      def app_name
+        doc.front_matter['app']
+      end
+
+      def rel_dir
+        doc.front_matter['dir']
+      end
+
       def session_name
         doc.front_matter['session_name'] || task&.session_name
       end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.265"
+  VERSION = "0.1.266"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.265
+  version: 0.1.266
 platform: ruby
 authors:
 - Joshua Toyota