hiiro 0.1.236 → 0.1.237

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57a61c731baafeb477c3f8a1acca82b825ec432019744221b87721bce49d0da3
-  data.tar.gz: b51a6debe29e2b95b4fd0f489bf905e041637c06ec971ec73d8cf09ae204bc3a
+  metadata.gz: 7b4988e7f5ab4be2b903187c815ec22bea49c3817c69b9520390758d5eb16ee0
+  data.tar.gz: d16582776302c496a387791be6dfb3424fb6c669af6efbcf38f25c555feb3e88
 SHA512:
-  metadata.gz: a3e55905cbfc8c4f80d28fd3b4cfdfc04c5cf7566e20efb091a9ed945d0aa45907d45b085d3828506f20d43a07eb79e7991af6f9adb47b0ed197a6474ee66934
-  data.tar.gz: 3ecc52af4a2d7d822a10df2e78a994929280640cbe76ac7badd1039911cf54784437bbbb2961065972b0ad06e61c950dc092e3cd031c482f831919258e7a4965
+  metadata.gz: bd23321769a10e3181d1e88ef9f6a953ff86fab5d4037e03058a55760ae22f64082e20a779f372a06d1f588909733a82ead732ce0d305f05873846913bc01937
+  data.tar.gz: a67d8dbd70576be90258660e17708ecb86b0d823cbc10be838f05ddeb1fb1de307ec72b8d9d1247f96cbbbca2a0a5734beb89b0e39e53547663fbdd48ebdc570

data/bin/h-branch

@@ -116,14 +116,130 @@ class BranchManager
   end
 end
 
+BRANCH_TAG_OPTS = Proc.new {
+  option(:tag, short: 't', desc: 'filter by tag (OR when multiple)', multi: true)
+}
+
 Hiiro.run(*ARGV) do
-  manager = BranchManager.new(self)
+  manager   = BranchManager.new(self)
+  tag_store = Hiiro::Tags.new(:branch)
 
   add_subcmd(:edit) { edit_files(__FILE__) }
   add_subcmd(:save) { manager.save }
   add_subcmd(:current) { print `git branch --show-current` }
   add_subcmd(:info) { manager.current }
 
+  add_subcmd(:ls) do |*ls_args|
+    opts     = Hiiro::Options.parse(ls_args, &BRANCH_TAG_OPTS)
+    branches = git.branches(sort_by: 'authordate', ignore_case: true)
+    current  = git.branch
+    tags_all = tag_store.all  # { branch_name => [tags] }
+
+    tag_filter = Array(opts.tag).reject(&:empty?)
+    if tag_filter.any?
+      branches = branches.select { |b| (Array(tags_all[b]) & tag_filter).any? }
+    end
+
+    if branches.empty?
+      puts tag_filter.any? ? "No branches match tags: #{tag_filter.join(', ')}" : "No branches found."
+      next
+    end
+
+    branches.each do |b|
+      marker   = b == current ? "* " : "  "
+      tags     = Array(tags_all[b])
+      tag_str  = tags.any? ? "  " + Hiiro::Tags.badges(tags) : ""
+      puts "#{marker}#{b}#{tag_str}"
+    end
+  end
+
+  add_subcmd(:tag) do |*raw_args|
+    opts     = Hiiro::Options.parse(raw_args) { flag(:edit, short: 'e', desc: 'open YAML editor to bulk-tag branches') }
+    branches = git.branches(sort_by: 'authordate', ignore_case: true)
+
+    if opts.edit
+      branch_lines = branches.map { |b| "- #{b}" }
+      yaml_content = <<~YAML
+        # Select branches to tag and list the tags to apply.
+        # All listed branches will receive all listed tags.
+
+        branches:
+        #{branch_lines.join("\n")}
+
+        tags:
+        -
+      YAML
+
+      require 'tempfile'
+      tmpfile = Tempfile.new(['branch-tag-', '.yml'])
+      tmpfile.write(yaml_content)
+      tmpfile.close
+      edit_files(tmpfile.path)
+
+      parsed = YAML.safe_load(File.read(tmpfile.path)) rescue nil
+      tmpfile.unlink
+
+      unless parsed.is_a?(Hash)
+        puts "Aborted: could not parse YAML"
+        next
+      end
+
+      selected = Array(parsed['branches']).map(&:to_s).reject(&:empty?)
+      new_tags = Array(parsed['tags']).map(&:to_s).reject(&:empty?)
+
+      if selected.empty? || new_tags.empty?
+        puts "Aborted: need at least one branch and one tag"
+        next
+      end
+
+      selected.each do |b|
+        tag_store.add(b, *new_tags)
+        puts "Tagged #{b} with: #{new_tags.join(', ')}"
+      end
+    else
+      branch   = opts.args[0] || git.branch
+      tag_names = opts.args[1..]
+
+      if tag_names.empty?
+        puts "Usage: h branch tag [branch] <tag> [tag2 ...]"
+        puts "       h branch tag -e  (bulk edit mode)"
+        next
+      end
+
+      result = tag_store.add(branch, *tag_names)
+      puts "Tagged #{branch} with: #{tag_names.join(', ')}"
+      puts "  Tags now: #{result.join(', ')}"
+    end
+  end
+
+  add_subcmd(:untag) do |*raw_args|
+    branch    = raw_args[0] || git.branch
+    tag_names = raw_args[1..]
+
+    tag_store.remove(branch, *tag_names)
+    if tag_names.empty?
+      puts "Cleared all tags from #{branch}"
+    else
+      puts "Removed #{tag_names.join(', ')} from #{branch}"
+    end
+  end
+
+  add_subcmd(:tags) do
+    all = tag_store.all
+    if all.empty?
+      puts "No tagged branches."
+      next
+    end
+
+    by_tag = Hash.new { |h, k| h[k] = [] }
+    all.each { |branch, tags| tags.each { |t| by_tag[t] << branch } }
+
+    by_tag.sort.each do |tag, brs|
+      puts "#{Hiiro::Tags.badges([tag])} (#{brs.length})"
+      brs.each { |b| puts "  #{b}" }
+    end
+  end
+
   add_subcmd(:select) do |*select_args|
     branches = git.branches(sort_by: 'authordate', ignore_case: true)
 

data/bin/h-pr

@@ -392,7 +392,7 @@ class PinnedPRManager
 
   def filter_active?(opts)
     FILTER_PREDICATES.keys.any? { |f| opts.respond_to?(f) && opts.send(f) } ||
-      (opts.respond_to?(:tag) && opts.tag)
+      (opts.respond_to?(:tag) && Array(opts.tag).any?)
   end
 
   def apply_filters(prs, opts, forced: [])
@@ -401,10 +401,10 @@ class PinnedPRManager
 
     results = active.empty? ? prs : prs.select { |pr| active.any? { |f| FILTER_PREDICATES[f]&.call(pr) } }
 
-    # Tag is an AND post-filter — narrows whatever the flag filters returned
-    if opts.respond_to?(:tag) && opts.tag
-      tag = opts.tag.to_s
-      results = results.select { |pr| Array(pr['tags']).include?(tag) }
+    # Tags are an AND post-filter; multiple tags are OR'd among themselves
+    tag_filter = Array(opts.respond_to?(:tag) ? opts.tag : nil).map(&:to_s).reject(&:empty?)
+    unless tag_filter.empty?
+      results = results.select { |pr| (Array(pr['tags']) & tag_filter).any? }
     end
 
     results
@@ -488,7 +488,7 @@ FILTER_OPTS = Proc.new {
   flag(:merged,    short: 'm', desc: 'filter: merged PRs')
   flag(:active,    short: 'o', desc: 'filter: open (non-merged) PRs')
   flag(:numbers,   short: 'n', desc: 'output PR numbers only (no #)')
-  option(:tag,     short: 't', desc: 'filter by tag (AND with other filters)')
+  option(:tag,     short: 't', desc: 'filter by tag (OR when multiple; AND with flag filters)', multi: true)
 }
 
 Hiiro.run(*ARGV, plugins: [Pins]) do
@@ -1332,26 +1332,94 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
 
   # === Tags ===
 
-  add_subcmd(:tag) do |ref = nil, *tag_names|
-    if ref.nil? || tag_names.empty?
-      puts "Usage: h pr tag <ref> <tag> [tag2 ...]"
-      next
+  add_subcmd(:tag) do |*raw_args|
+    opts = Hiiro::Options.parse(raw_args) do
+      flag(:edit, short: 'e', desc: 'open YAML editor to bulk-tag multiple PRs')
     end
 
-    pr_number = resolve_pr.call(ref)
-    next unless pr_number
+    if opts.edit
+      pinned = pinned_manager.load_pinned
 
-    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 pinned.empty?
+        puts "No tracked PRs to tag"
+        next
+      end
 
-    pr['tags'] = (Array(pr['tags']) + tag_names).uniq
-    pinned_manager.save_pinned(pinned)
-    puts "Tagged ##{pr_number} with: #{tag_names.join(', ')}"
-    puts "  Tags now: #{pr['tags'].join(', ')}"
+      pr_lines = pinned.map do |pr|
+        branch = pr['headRefName'] ? "[#{pr['headRefName']}]" : "[##{pr['number']}]"
+        "- #{pr['number']}  # #{branch} #{pr['title']}"
+      end
+
+      yaml_content = <<~YAML
+        # Select PRs to tag and list the tags to apply.
+        # All listed PRs will receive all listed tags.
+        # Lines starting with # are comments and are ignored.
+
+        prs:
+        #{pr_lines.join("\n")}
+
+        tags:
+        -
+      YAML
+
+      tmpfile = Tempfile.new(['pr-tag-', '.yml'])
+      tmpfile.write(yaml_content)
+      tmpfile.close
+      edit_files(tmpfile.path)
+
+      parsed = YAML.safe_load(File.read(tmpfile.path)) rescue nil
+      tmpfile.unlink
+
+      unless parsed.is_a?(Hash)
+        puts "Aborted: could not parse YAML"
+        next
+      end
+
+      selected_numbers = Array(parsed['prs']).map(&:to_s).reject(&:empty?)
+      new_tags         = Array(parsed['tags']).map(&:to_s).reject(&:empty?)
+
+      if selected_numbers.empty? || new_tags.empty?
+        puts "Aborted: need at least one PR and one tag"
+        next
+      end
+
+      pinned = pinned_manager.load_pinned
+      updated = 0
+      selected_numbers.each do |num|
+        pr = pinned.find { |p| p['number'].to_s == num }
+        next unless pr
+        pr['tags'] = (Array(pr['tags']) + new_tags).uniq
+        updated += 1
+        puts "Tagged ##{num} with: #{new_tags.join(', ')}"
+      end
+
+      pinned_manager.save_pinned(pinned)
+      puts "Updated #{updated} PR(s)."
+    else
+      ref       = opts.args[0]
+      tag_names = opts.args[1..]
+
+      if ref.nil? || tag_names.empty?
+        puts "Usage: h pr tag <ref> <tag> [tag2 ...]"
+        puts "       h pr tag -e  (bulk edit mode)"
+        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
+
+      pr['tags'] = (Array(pr['tags']) + tag_names).uniq
+      pinned_manager.save_pinned(pinned)
+      puts "Tagged ##{pr_number} with: #{tag_names.join(', ')}"
+      puts "  Tags now: #{pr['tags'].join(', ')}"
+    end
   end
 
   add_subcmd(:untag) do |ref = nil, *tag_names|

data/lib/hiiro/tags.rb

@@ -0,0 +1,71 @@
+class Hiiro
+  # Shared tag store, keyed by namespace (e.g. :branch, :task).
+  # Stored in ~/.config/hiiro/tags.yml as { namespace => { key => [tags] } }.
+  class Tags
+    FILE = Hiiro::Config.path('tags.yml')
+
+    def initialize(namespace)
+      @namespace = namespace.to_s
+    end
+
+    # Returns the tag array for a given key ([] if none).
+    def get(key)
+      Array(load.dig(@namespace, key.to_s))
+    end
+
+    # Adds tags to a key (idempotent). Returns the new tag array.
+    def add(key, *tags)
+      data = load
+      data[@namespace] ||= {}
+      current = Array(data.dig(@namespace, key.to_s))
+      data[@namespace][key.to_s] = (current + tags.map(&:to_s)).uniq
+      save(data)
+      data[@namespace][key.to_s]
+    end
+
+    # Removes specific tags from a key. Pass no tags to clear all.
+    def remove(key, *tags)
+      data = load
+      data[@namespace] ||= {}
+      current = Array(data.dig(@namespace, key.to_s))
+      updated = tags.empty? ? [] : (current - tags.map(&:to_s))
+      if updated.empty?
+        data[@namespace].delete(key.to_s)
+      else
+        data[@namespace][key.to_s] = updated
+      end
+      save(data)
+    end
+
+    # Returns the full { key => [tags] } hash for this namespace.
+    def all
+      load[@namespace] || {}
+    end
+
+    # Returns all distinct tag values used in this namespace.
+    def known_tags
+      all.values.flatten.uniq.sort
+    end
+
+    # Formats a tag array as colored badges for terminal output.
+    def self.badges(tags)
+      Array(tags).map { |t| "\e[30;104m#{t}\e[0m" }.join(' ')
+    end
+
+    private
+
+    def load
+      return {} unless File.exist?(FILE)
+      YAML.safe_load(File.read(FILE)) || {}
+    rescue
+      {}
+    end
+
+    def save(data)
+      data.each { |_, v| v.reject! { |_, tags| tags.nil? || tags.empty? } if v.is_a?(Hash) }
+      data.reject! { |_, v| v.nil? || v.empty? }
+      FileUtils.mkdir_p(File.dirname(FILE))
+      File.write(FILE, data.to_yaml)
+    end
+  end
+end

data/lib/hiiro/tasks.rb

@@ -182,11 +182,21 @@ class Hiiro
       puts "Stopped task '#{task.name}' (worktree available for reuse)"
     end
 
-    def list
+    def list(tags_filter: [])
+      tag_store = Hiiro::Tags.new(:task)
       items = tasks
+
+      if tags_filter.any?
+        items = items.select { |t| (tag_store.get(t.name) & tags_filter).any? }
+      end
+
       if items.empty?
-        puts scope == :subtask ? "No subtasks found" : "No tasks found"
-        puts "Use 'h #{scope} start NAME' to create one."
+        if tags_filter.any?
+          puts "No #{scope == :subtask ? 'subtasks' : 'tasks'} match tags: #{tags_filter.join(', ')}"
+        else
+          puts scope == :subtask ? "No subtasks found" : "No tasks found"
+          puts "Use 'h #{scope} start NAME' to create one."
+        end
         return
       end
 
@@ -227,9 +237,11 @@ class Hiiro
 
       rows.each do |r|
         name_pad = name_col - r[:prefix].length
+        tags     = tag_store.get(r[:name])
+        tag_str  = tags.any? ? "  " + Hiiro::Tags.badges(tags) : ""
         print r[:prefix]
         puts format("%-#{name_pad}s  %-#{tree_col}s  %-#{branch_col}s  %s",
-                    r[:name], r[:tree], r[:branch], r[:session])
+                    r[:name], r[:tree], r[:branch], r[:session]) + tag_str
       end
 
       available = environment.all_trees.reject { |t|
@@ -649,8 +661,76 @@ class Hiiro
   module Tasks
     def self.build_hiiro(parent_hiiro, tm)
       task_hiiro = parent_hiiro.make_child do |h|
-        h.add_subcmd(:list) { tm.list }
-        h.add_subcmd(:ls) { tm.list }
+        h.add_subcmd(:list) do |*args|
+          opts = Hiiro::Options.parse(args) { option(:tag, short: 't', desc: 'filter by tag (OR when multiple)', multi: true) }
+          tm.list(tags_filter: Array(opts.tag).reject(&:empty?))
+        end
+        h.add_subcmd(:ls) do |*args|
+          opts = Hiiro::Options.parse(args) { option(:tag, short: 't', desc: 'filter by tag (OR when multiple)', multi: true) }
+          tm.list(tags_filter: Array(opts.tag).reject(&:empty?))
+        end
+
+        h.add_subcmd(:tag) do |*raw_args|
+          tag_store = Hiiro::Tags.new(:task)
+          opts      = Hiiro::Options.parse(raw_args) { flag(:edit, short: 'e', desc: 'open YAML editor to bulk-tag tasks') }
+
+          if opts.edit
+            task_names = tm.tasks.map(&:name)
+            task_lines = task_names.map { |n| "- #{n}" }
+            yaml_content = "# Select tasks to tag.\n\ntasks:\n#{task_lines.join("\n")}\n\ntags:\n-\n"
+            require 'tempfile'
+            tmpfile = Tempfile.new(['task-tag-', '.yml'])
+            tmpfile.write(yaml_content)
+            tmpfile.close
+            h.edit_files(tmpfile.path)
+            parsed   = YAML.safe_load(File.read(tmpfile.path)) rescue nil
+            tmpfile.unlink
+            selected = Array(parsed&.dig('tasks')).map(&:to_s).reject(&:empty?)
+            new_tags = Array(parsed&.dig('tags')).map(&:to_s).reject(&:empty?)
+            if selected.empty? || new_tags.empty?
+              puts "Aborted: need at least one task and one tag"
+              next
+            end
+            selected.each { |n| tag_store.add(n, *new_tags); puts "Tagged #{n} with: #{new_tags.join(', ')}" }
+          else
+            task_name = opts.args[0] || tm.current_task&.name
+            tag_names = opts.args[1..]
+            if task_name.nil? || tag_names.empty?
+              puts "Usage: h task tag [task_name] <tag> [tag2 ...]"
+              next
+            end
+            result = tag_store.add(task_name, *tag_names)
+            puts "Tagged #{task_name} with: #{tag_names.join(', ')}"
+            puts "  Tags now: #{result.join(', ')}"
+          end
+        end
+
+        h.add_subcmd(:untag) do |*raw_args|
+          tag_store = Hiiro::Tags.new(:task)
+          task_name = raw_args[0] || tm.current_task&.name
+          tag_names = raw_args[1..]
+          if task_name.nil?
+            puts "Usage: h task untag [task_name] [tag ...]"
+            next
+          end
+          tag_store.remove(task_name, *tag_names)
+          puts tag_names.empty? ? "Cleared all tags from #{task_name}" : "Removed #{tag_names.join(', ')} from #{task_name}"
+        end
+
+        h.add_subcmd(:tags) do
+          tag_store = Hiiro::Tags.new(:task)
+          all       = tag_store.all
+          if all.empty?
+            puts "No tagged tasks."
+            next
+          end
+          by_tag = Hash.new { |h2, k| h2[k] = [] }
+          all.each { |task, tags| tags.each { |t| by_tag[t] << task } }
+          by_tag.sort.each do |tag, tasks|
+            puts "#{Hiiro::Tags.badges([tag])} (#{tasks.length})"
+            tasks.each { |t| puts "  #{t}" }
+          end
+        end
 
         h.add_subcmd(:start) do |*raw_args|
           opts = Hiiro::Options.parse(raw_args) do

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.236"
+  VERSION = "0.1.237"
 end

data/lib/hiiro.rb

@@ -14,6 +14,7 @@ require_relative "hiiro/matcher"
 require_relative "hiiro/notification"
 require_relative "hiiro/options"
 require_relative "hiiro/paths"
+require_relative "hiiro/tags"
 require_relative "hiiro/queue"
 require_relative "hiiro/tasks"
 require_relative "hiiro/tmux"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.236
+  version: 0.1.237
 platform: ruby
 authors:
 - Joshua Toyota
@@ -158,6 +158,7 @@ files:
 - lib/hiiro/runner_tool.rb
 - lib/hiiro/service_manager.rb
 - lib/hiiro/shell.rb
+- lib/hiiro/tags.rb
 - lib/hiiro/tasks.rb
 - lib/hiiro/tmux.rb
 - lib/hiiro/tmux/buffer.rb