hiiro 0.1.337 → 0.1.339

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdc7066a25c11d282e6e13914e89d1f17b93b1e6eebaadb3b78c445e9ad54730
-  data.tar.gz: ccfe1dacaa0fadff21f621d56743d99066fec4f911de70a58741504b8a9330a3
+  metadata.gz: bcaeb672d1c537efc87a229a1db28b61533c42507dc9418732297d0564cb0903
+  data.tar.gz: 8d90d568d5a7d4b601a267deb60039c74acec7b1151fe1026dac06f60669bdf1
 SHA512:
-  metadata.gz: 1c52eefc3e02bb0eadee1019f091facbfcd01509d6e57c32214032f901aebf3b0204afa1aacff3dfb3c4f9d793b298d11cf888fb02c6ddc24a0948c7737526c7
-  data.tar.gz: f2cc1b1cfbfae9fc3c6229e140779deeee162458d2b04e1ac04a61ea515e13161f5d6a70c93316c5f1c7bfc895baa8552c809d199434e4b42dd2f90d45be91e2
+  metadata.gz: 43edf56c4056bb07b893c6c93a7b34cf2ea760d52f94f8c243835250c3bcf3c508a61ec3e7ab835d61808e8fc87bf4a400d9387a5afbe4e660c7ca32f30d084a
+  data.tar.gz: 63a2754cfebf1a3fba0d6145d9abd7df41b8b2d90a6a0342f2da9d23a9a3674bde800bce9b000d9de587e5de7e01ef7f7f0e7345f76a319c06b53895463067bf

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.1.339] - 2026-04-07
+
+### Added
+- `h ps byport <port> [port2 ...]` — find processes listening on specified port(s)
+- `PsProcess.by_port(*ports)` — query processes by listening port numbers
+- `h task switch` now matches ~/proj/* directories by prefix as fallback when task name doesn't match
+
+## [0.1.338] - 2026-04-07
+
+### Changed
+- `h pr watch`, `h pr fwatch`, `h pr check` now default to current branch's PR (use `-s` to select via fuzzyfinder)
+- Renamed `registry_entries` table to `registry` (auto-migrates existing data)
+
 ## [0.1.337] - 2026-04-06
 
 ### Changed
@@ -311,73 +324,4 @@
 - `bin/h-link` — reads/writes links via `Hiiro::Link` SQLite model with YAML dual-write fallback; adds `q`/`query` subcommands
 - `bin/h-pane` — load/save pane homes via `Hiiro::PaneHome` model with YAML dual-write
 - `bin/h-pr` — adds `q`/`query` subcommands for inspecting PR records via raw SQL
-- `plugins/pins.rb` — `Pin` class reads/writes via `Hiiro::PinRecord` SQLite model with YAML dual-write fallback
-
-## [0.1.306] - 2026-03-30
-
-### Changed
-- Increase delayed_update sleep duration from 5s to 15s
-- Add logging for delayed_update invocation in publish script
-
-## [0.1.305] - 2026-03-30
-
-### Changed
-- Refactor: use delayed_update subcommand instead of direct update call
-- Improve gem version matching regex in version check
-
-## [0.1.304] - 2026-03-30
-
-### Changed
-- h-notify: use universal log instead of per-session logging
-- Todo output simplified
-
-## [0.1.302] - 2026-03-30
-
-### Fixed
-- Truncate output lines to terminal width in tasks plugin
-
-## [0.1.301]
-
-### Added
-- Check version delayed update functionality
-
-### Changed
-- h-claude: add verbose flags and refactor glob_path handling
-
-### Fixed
-- Use exact session matching to prevent tmux prefix ambiguity
-
-## [0.1.300]
-
-### Added
-- h-claude: fulltext search option for agents/commands/skills
-
-### Changed
-- Refactor h-claude directory traversal and file globbing
-
-## [0.1.299]
-
-### Added
-- h-pr open: support opening multiple PRs
-
-## [0.1.298]
-
-### Changed
-- Use Pathname to walk up directory tree
-- h-claude agents/commands/skills walk from pwd up to home
-
-## [0.1.297]
-
-### Added
-- h rnext subcommand
-
-## [0.1.296]
-
-### Changed
-- Refactor PR filter logic to pinned_pr_manager
-- Move PR filter logic to Pr#matches_filters?
-
-## [0.1.295]
-
-### Changed
-- Filter logic changes for PR management
+- `plugins/pins.rb` — `Pin` class reads/writes via `Hiiro::PinRecord` SQLite model with YAML dual-write fallback

data/bin/h-pr

@@ -11,11 +11,30 @@ Hiiro.run(*ARGV, plugins: [Pins]) do
   pm = pinned_manager = Hiiro::PinnedPRManager.new
   Hiiro::PinnedPRManager.add_resolvers(self)
 
-  watch_block = ->(original_pr_number=nil, *watch_args) {
+  watch_block = ->(*all_args) {
+    opts = Hiiro::Options.setup {
+      option(:select, short: :s, type: :flag, desc: 'Select PR via fuzzyfinder')
+    }.parse(all_args)
+    
+    original_pr_number = opts.args.first
+    watch_args = opts.args[1..] || []
     watch = get_value(:watch)
     fail_fast = get_value(:fail_fast)
 
-    pr_number = resolve(:pr, original_pr_number)
+    pr_number = if opts.select
+      resolve(:pr, nil)  # triggers fuzzyfinder
+    elsif original_pr_number
+      resolve(:pr, original_pr_number)
+    else
+      # Default to current branch's PR
+      current_pr = pm.fetch_current_branch_pr
+      if current_pr
+        current_pr.number.to_s
+      else
+        STDERR.puts "No PR for current branch. Use -s to select or provide a PR number."
+        nil
+      end
+    end
     return unless pr_number
 
     base_cmd = %w[gh pr checks]

data/bin/h-ps

@@ -20,6 +20,21 @@ Hiiro.run(*ARGV) do
     end
   end
 
+  add_subcmd(:byport) { |*ports|
+    if ports.empty?
+      puts "Usage: h ps byport <port> [port2 ...]"
+      next
+    end
+
+    processes = Hiiro::PsProcess.by_port(*ports)
+
+    if processes.empty?
+      puts "No processes found on port(s): #{ports.join(', ')}"
+    else
+      processes.each { |p| puts "#{p.pid}\t#{p.dir || '(unknown)'}" }
+    end
+  }
+
   add_subcmd(:search) { |pattern = nil|
     if pattern.nil?
       puts "Usage: h ps search <pattern>"

data/bin/h-registry

@@ -21,8 +21,9 @@ Hiiro.run(*ARGV, tasks: true) do
         puts '─' * 40
       end
       alias_col = e.short_name ? "[#{e.short_name}]".ljust(18) : ' ' * 18
+      value_col = e.value ? " = #{e.value}" : ''
       desc_col  = e.description ? "  # #{e.description}" : ''
-      puts "  #{alias_col} #{e.name}#{desc_col}"
+      puts "  #{alias_col} #{e.name}#{value_col}#{desc_col}"
     end
     puts
   end
@@ -33,10 +34,10 @@ Hiiro.run(*ARGV, tasks: true) do
     puts types.empty? ? "No types registered yet." : types.join("\n")
   end
 
-  # h registry add <type> <name> [--alias <short>] [--desc <description>]
+  # h registry add <type> <name> [value] [--alias <short>] [--desc <description>]
   add_subcmd(:add) do |type, name, *rest|
     unless type && name
-      puts "Usage: h registry add <type> <name> [--alias <short>] [--desc <text>]"
+      puts "Usage: h registry add <type> <name> [value] [--alias <short>] [--desc <text>]"
       next
     end
     opts = Hiiro::Options.setup {
@@ -44,6 +45,9 @@ Hiiro.run(*ARGV, tasks: true) do
       option(:desc,  short: :d, desc: 'Description')
     }.parse(rest)
 
+    # First positional arg after name is the value
+    value = opts.args.first
+
     existing = Hiiro::RegistryEntry.find_by_ref(name, type: type)
     if existing
       puts "Already registered: #{existing.display}"
@@ -53,6 +57,7 @@ Hiiro.run(*ARGV, tasks: true) do
     entry = Hiiro::RegistryEntry.create(
       resource_type: type,
       name:          name,
+      value:         value,
       short_name:    opts.alias,
       description:   opts.desc,
       created_at:    Time.now.iso8601
@@ -60,15 +65,26 @@ Hiiro.run(*ARGV, tasks: true) do
     puts "Added:\n#{entry.display}"
   end
 
-  # h registry rm <name_or_alias> [type]
-  add_subcmd(:rm, :remove) do |ref, type = nil|
+  # h registry rm <name_or_alias> [type] [-s]
+  add_subcmd(:rm, :remove) do |*args|
+    opts = Hiiro::Options.setup {
+      option(:substring, short: :s, type: :flag, desc: 'Match substring anywhere in name')
+    }.parse(args)
+    
+    ref, type = opts.args
     unless ref
-      puts "Usage: h registry rm <name_or_alias> [type]"
+      puts "Usage: h registry rm <name_or_alias> [type] [-s]"
       next
     end
-    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type ? type.to_s : nil)
+    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type&.to_s, substring: opts.substring)
     unless entry
-      puts "Not found: #{ref}#{type ? " (type: #{type})" : ''}"
+      matches = Hiiro::RegistryEntry.find_all_by_ref(ref, type: type&.to_s, substring: opts.substring)
+      if matches.any?
+        puts "Ambiguous match '#{ref}' - #{matches.size} entries:"
+        matches.each { |e| puts "  #{e.resource_type}/#{e.name}" }
+      else
+        puts "Not found: #{ref}#{type ? " (type: #{type})" : ''}"
+      end
       next
     end
     puts "Removing: #{entry.display}"
@@ -76,24 +92,52 @@ Hiiro.run(*ARGV, tasks: true) do
     puts "Done."
   end
 
-  # h registry get <name_or_alias> [type] — prints canonical name (scriptable)
-  add_subcmd(:get) do |ref, type = nil|
+  # h registry get <name_or_alias> [type] [-s] — prints value (or name if no value)
+  # Supports prefix matching; use -s/--substring for substring match
+  # Prints all matching values (one per line) if multiple matches
+  add_subcmd(:get) do |*args|
+    opts = Hiiro::Options.setup {
+      option(:substring, short: :s, type: :flag, desc: 'Match substring anywhere in name')
+    }.parse(args)
+    
+    ref, type = opts.args
     unless ref
-      puts "Usage: h registry get <name_or_alias> [type]"
+      puts "Usage: h registry get <name_or_alias> [type] [-s]"
       next
     end
-    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type ? type.to_s : nil)
-    entry ? puts(entry.name) : exit(1)
+    
+    matches = Hiiro::RegistryEntry.find_all_by_ref(ref, type: type&.to_s, substring: opts.substring)
+    if matches.empty?
+      exit(1)
+    else
+      matches.each { |e| puts(e.value || e.name) }
+    end
   end
 
-  # h registry show <name_or_alias> [type] — human-readable detail
-  add_subcmd(:show) do |ref, type = nil|
+  # h registry show <name_or_alias> [type] [-s] — human-readable detail
+  add_subcmd(:show) do |*args|
+    opts = Hiiro::Options.setup {
+      option(:substring, short: :s, type: :flag, desc: 'Match substring anywhere in name')
+    }.parse(args)
+    
+    ref, type = opts.args
     unless ref
-      puts "Usage: h registry show <name_or_alias> [type]"
+      puts "Usage: h registry show <name_or_alias> [type] [-s]"
       next
     end
-    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type ? type.to_s : nil)
-    entry ? puts(entry.display) : (puts "Not found: #{ref}"; exit 1)
+    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type&.to_s, substring: opts.substring)
+    if entry
+      puts entry.display
+    else
+      matches = Hiiro::RegistryEntry.find_all_by_ref(ref, type: type&.to_s, substring: opts.substring)
+      if matches.any?
+        puts "Ambiguous match '#{ref}' - #{matches.size} entries:"
+        matches.each { |e| puts "  #{e.resource_type}/#{e.name}" }
+      else
+        puts "Not found: #{ref}"
+      end
+      exit 1
+    end
   end
 
   # h registry select [type] — fuzzyfinder, prints canonical name
@@ -110,19 +154,50 @@ Hiiro.run(*ARGV, tasks: true) do
     puts name
   end
 
-  # h registry set-alias <name_or_alias> <new_alias> [type]
-  add_subcmd(:'set-alias') do |ref, new_alias, type = nil|
+  # h registry set-alias <name_or_alias> <new_alias> [type] [-s]
+  add_subcmd(:'set-alias') do |*args|
+    opts = Hiiro::Options.setup {
+      option(:substring, short: :s, type: :flag, desc: 'Match substring anywhere in name')
+    }.parse(args)
+    
+    ref, new_alias, type = opts.args
     unless ref && new_alias
-      puts "Usage: h registry set-alias <name_or_alias> <new_alias> [type]"
+      puts "Usage: h registry set-alias <name_or_alias> <new_alias> [type] [-s]"
       next
     end
-    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type ? type.to_s : nil)
+    entry = Hiiro::RegistryEntry.find_by_ref(ref, type: type&.to_s, substring: opts.substring)
     unless entry
-      puts "Not found: #{ref}"
+      matches = Hiiro::RegistryEntry.find_all_by_ref(ref, type: type&.to_s, substring: opts.substring)
+      if matches.any?
+        puts "Ambiguous match '#{ref}' - #{matches.size} entries:"
+        matches.each { |e| puts "  #{e.resource_type}/#{e.name}" }
+      else
+        puts "Not found: #{ref}"
+      end
       next
     end
     entry.update(short_name: new_alias)
     puts entry.display
   end
 
+  # h registry set <type> <name> <value> — update value of existing entry (or create)
+  add_subcmd(:set, :update) do |type, name, value = nil|
+    unless type && name
+      puts "Usage: h registry set <type> <name> <value>"
+      next
+    end
+    entry = Hiiro::RegistryEntry.find_by_ref(name, type: type)
+    if entry
+      entry.update(value: value)
+    else
+      entry = Hiiro::RegistryEntry.create(
+        resource_type: type,
+        name:          name,
+        value:         value,
+        created_at:    Time.now.iso8601
+      )
+    end
+    puts entry.display
+  end
+
 end

data/lib/hiiro/db.rb

@@ -37,6 +37,8 @@ class Hiiro
 
         MODELS.each do |cls|
           cls.create_table!(conn)
+          # Run model-specific migrations (e.g., adding columns to existing tables)
+          cls.migrate!(conn) if cls.respond_to?(:migrate!)
           # Clear all schema-related caches on the model and its anonymous Sequel
           # parent class. When require_valid_table=false and the table didn't exist
           # at class-definition time, Sequel caches empty results for @db_schema,

data/lib/hiiro/ps_process.rb

@@ -54,6 +54,22 @@ class Hiiro::PsProcess
     all.find { |p| p.pid == pid.to_s }
   end
 
+  # Find processes listening on given port numbers
+  def self.by_port(*ports)
+    pids = Set.new
+    ports.each do |port|
+      lsof_output = `lsof -i :#{port.to_i} 2>/dev/null`.lines[1..]
+      next unless lsof_output
+
+      lsof_output.each do |line|
+        fields = line.split
+        pids << fields[1] if fields[1]
+      end
+    end
+
+    all.select { |p| pids.include?(p.pid) }
+  end
+
   # Find processes with files open in given directories
   def self.in_dirs(*paths)
     pids = Set.new

data/lib/hiiro/registry.rb

@@ -1,14 +1,20 @@
 require 'sequel'
 
 class Hiiro
-  class RegistryEntry < Sequel::Model(:registry_entries)
+  class RegistryEntry < Sequel::Model(:registry)
     Hiiro::DB.register(self)
 
     def self.create_table!(db)
-      db.create_table?(:registry_entries) do
+      # Rename old table if it exists
+      if db.table_exists?(:registry_entries) && !db.table_exists?(:registry)
+        db.rename_table(:registry_entries, :registry)
+      end
+      
+      db.create_table?(:registry) do
         primary_key :id
         String :resource_type, null: false   # e.g. "service", "queue", "worker"
         String :name,          null: false   # canonical identifier
+        String :value                        # stored value (optional)
         String :short_name                   # alias / shorthand
         String :description
         String :meta_json                    # arbitrary JSON for extra fields
@@ -18,16 +24,65 @@ class Hiiro
       end
     end
 
+    def self.migrate!(db)
+      # Add value column if missing (migration for existing DBs)
+      unless db.schema(:registry).any? { |col, _| col == :value }
+        db.alter_table(:registry) { add_column :value, String }
+      end
+    end
+
     # ── Finders ──────────────────────────────────────────────────────────────
 
     def self.of_type(type)       = where(resource_type: type.to_s).order(:name).all
     def self.all_ordered         = order(:resource_type, :name).all
     def self.known_types         = distinct.select_map(:resource_type).sort
 
-    # Resolve by exact name or short_name within a type (or globally).
-    def self.find_by_ref(ref, type: nil)
+    # Resolve by exact name, short_name, or prefix within a type (or globally).
+    # Returns single entry or nil. Ambiguous prefix matches return nil.
+    def self.find_by_ref(ref, type: nil, substring: false)
+      scope = type ? where(resource_type: type.to_s) : self
+      
+      # Try exact match first (name or short_name)
+      exact = scope.where(name: ref).first || scope.where(short_name: ref).first
+      return exact if exact
+      
+      # Fall back to prefix/substring matching
+      entries = scope.all
+      matcher = Hiiro::Matcher.new(entries, :name)
+      result = substring ? matcher.by_substring(ref) : matcher.by_prefix(ref)
+      
+      # Only return if unambiguous (exactly one match)
+      return result.first.item if result.one?
+      
+      # Also try matching against short_name
+      matcher_short = Hiiro::Matcher.new(entries.select(&:short_name), :short_name)
+      result_short = substring ? matcher_short.by_substring(ref) : matcher_short.by_prefix(ref)
+      return result_short.first.item if result_short.one?
+      
+      nil
+    end
+    
+    # Find all entries matching ref (for showing ambiguous matches)
+    # Checks both name and short_name, returns unique entries
+    def self.find_all_by_ref(ref, type: nil, substring: false)
       scope = type ? where(resource_type: type.to_s) : self
-      scope.where(name: ref).first || scope.where(short_name: ref).first
+      
+      # Check for exact matches first
+      exact = scope.where(name: ref).all + scope.where(short_name: ref).all
+      return exact.uniq(&:id) if exact.any?
+      
+      # Fall back to prefix/substring matching on name
+      entries = scope.all
+      matcher = Hiiro::Matcher.new(entries, :name)
+      result = substring ? matcher.by_substring(ref) : matcher.by_prefix(ref)
+      name_matches = result.matches.map(&:item)
+      
+      # Also match on short_name
+      matcher_short = Hiiro::Matcher.new(entries.select(&:short_name), :short_name)
+      result_short = substring ? matcher_short.by_substring(ref) : matcher_short.by_prefix(ref)
+      short_matches = result_short.matches.map(&:item)
+      
+      (name_matches + short_matches).uniq(&:id)
     end
 
     # Fuzzy-finder display lines: "type  short  name  description"
@@ -51,12 +106,14 @@ class Hiiro
 
     def fuzzy_line
       parts = [resource_type.ljust(14), short_name&.ljust(16) || ' ' * 16, name]
+      parts << " = #{value}" if value && !value.empty?
       parts << "  # #{description}" if description && !description.empty?
       parts.join('  ').strip
     end
 
     def display
       lines = ["#{resource_type} / #{name}"]
+      lines << "  value:  #{value}"            if value
       lines << "  alias:  #{short_name}"       if short_name
       lines << "  desc:   #{description}"      if description
       meta.each { |k, v| lines << "  #{k}: #{v}" } unless meta.empty?

data/lib/hiiro/tasks.rb

@@ -964,6 +964,22 @@ class Hiiro
             end
           end
 
+          # If still no task/session found, check ~/proj/* directories by prefix
+          unless task
+            proj_dirs = Dir.glob(File.expand_path('~/proj/*/'))
+            dir_names = proj_dirs.map { |d| File.basename(d) }
+            result = Hiiro::Matcher.by_prefix(dir_names, task_name)
+            if result.one?
+              dir_name = result.first.item
+              h.start_tmux_session(dir_name, start_directory: File.expand_path("~/proj/#{dir_name}"))
+              puts "Switched to ~/proj/#{dir_name}"
+              next
+            elsif result.ambiguous?
+              puts "Ambiguous match for '#{task_name}': #{result.matches.map(&:item).join(', ')}"
+              exit 1
+            end
+          end
+
           tm.switch_to_task(task, app_name: app_name, force: opts.force)
         end
 

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.337"
+  VERSION = "0.1.339"
 end

metadata

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