hiiro 0.1.54 → 0.1.56

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed4284e83a1b52e665208b5e706de9017e9acfb3eedbcd0e1b265e3719292638
-  data.tar.gz: 23dbed41838b15eeaa2f312669da58bd5a2546a0b1cd52b6149b44bf54d7316e
+  metadata.gz: 0db0a8fd9d54e542cb2b5951197e2250a1d199a66278b31bab5c003b50d8f39f
+  data.tar.gz: bee3a32c0dc9e68379aee3963bb11b15041a9cd21715379dbbc086bff59eba17
 SHA512:
-  metadata.gz: 5ea8a092c971853fbf396ab63702dabf56e88abb09ca34ab170d45cf8cec0ae5a561ece441768136780f98b024657b93d9d3adb46174d15354fec6a9d3545d6b
-  data.tar.gz: 3677c376b5a84c7da0ffe69c10cddceb9c3c9446bfbee8aa37282a1e1b33cbd20534d98e67d6deacbc62a78480393d7b2238b1bb992a714903d670d9014b14cf
+  metadata.gz: b59060b23668b9f6fc2818884628dccae6a95e84a5554d9666b9ce79d9bfc45f231c486039121c6a33cc8e97b144e1579cbd637131d8ca5cd0f196bfcdb4e9ff
+  data.tar.gz: 5918af1c725ce23f22a17d273def7f656118c1a54f9fd13ee7fe0be708e82f8c8146c7a4b4c7860482c5fb85a5c8a86910c5412062a96d9c37ce9901b527bee7

data/bin/h-app

@@ -62,23 +62,21 @@ Hiiro.run(*ARGV, plugins: [:Tasks]) {
       next
     end
 
-    apps = load_apps
-    match = apps.find { |name, _| name.start_with?(app_name) }
+    app = environment.app_matcher.find(app_name)
 
-    if match
-      name, app_relative_path = match
-      target = File.join(root, app_relative_path)
+    if app
+      target = File.join(root, app.relative_path)
       send_cd(relative_cd_path(target))
     else
       puts "App '#{app_name}' not found"
       puts
       puts "Available apps:"
-      apps.each { |name, path| puts format("  %-20s => %s", name, path) }
+      environment.all_apps.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
     end
   }
 
   add_subcmd(:ls) {
-    apps = load_apps
+    apps = environment.all_apps
 
     if apps.empty?
       puts "No apps configured."
@@ -87,7 +85,7 @@ Hiiro.run(*ARGV, plugins: [:Tasks]) {
     else
       puts "Configured apps:"
       puts
-      apps.each { |name, path| puts format("  %-20s => %s", name, path) }
+      apps.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
     end
   }
 
@@ -104,12 +102,10 @@ Hiiro.run(*ARGV, plugins: [:Tasks]) {
       next
     end
 
-    apps = load_apps
-    match = apps.find { |name, _| name.start_with?(app_name) }
+    app = environment.app_matcher.find(app_name)
 
-    if match
-      name, app_relative_path = match
-      target = File.join(root, app_relative_path)
+    if app
+      target = File.join(root, app.relative_path)
       puts relative_cd_path(target)
     else
       puts "App '#{app_name}' not found"
@@ -129,12 +125,10 @@ Hiiro.run(*ARGV, plugins: [:Tasks]) {
       next
     end
 
-    apps = load_apps
-    match = apps.find { |name, _| name.start_with?(app_name) }
+    app = environment.app_matcher.find(app_name)
 
-    if match
-      name, app_relative_path = match
-      puts File.join(root, app_relative_path)
+    if app
+      puts File.join(root, app.relative_path)
     else
       puts "App '#{app_name}' not found"
     end

data/bin/h-plugin

@@ -23,7 +23,8 @@ o.add_subcmd(:edit) { |*args|
   if args.none?
     system(ENV['EDITOR'] || 'safe_nvim', __FILE__)
   else
-    plugins = plugin_files.select{|f| args.any?{|arg| File.basename(f).start_with?(arg) } }
+    pm = Hiiro::PrefixMatcher.new(plugin_files) { |f| File.basename(f) }
+    plugins = args.flat_map { |arg| pm.find_all(arg) }.uniq
 
     if plugins.none?
       puts "No matching plugins found for: #{args.map(&:inspect).join(' ')}"

data/exe/h

@@ -2,52 +2,55 @@
 
 require "hiiro"
 require "fileutils"
-
-hiiro = Hiiro.init(*ARGV, cwd: Dir.pwd, plugins: [Tasks])
-
-hiiro.add_subcommand(:version) { |*args|
-  puts Hiiro::VERSION
-}
-
-hiiro.add_subcommand(:ping) { |*args|
-  puts "pong"
-}
-
-hiiro.add_subcommand(:setup) do |*args|
-  gem_root = File.expand_path("../..", __FILE__)
-  source_plugins = File.join(gem_root, "plugins")
-  source_bins = File.join(gem_root, "bin")
-  dest_plugins = File.expand_path("~/.config/hiiro/plugins")
-  dest_bin = File.expand_path("~/bin")
-
-  FileUtils.mkdir_p(dest_plugins)
-  FileUtils.mkdir_p(dest_bin)
-
-  # Copy plugins
-  plugin_files = Dir["#{source_plugins}/*.rb"]
-  if plugin_files.any?
-    FileUtils.cp(plugin_files, dest_plugins)
-    puts "Installed #{plugin_files.size} plugins to #{dest_plugins}"
-    plugin_files.each { |f| puts "  - #{File.basename(f)}" }
-  else
-    puts "No plugins found in #{source_plugins}"
-  end
-
-  puts
-
-  # Copy bin scripts
-  bin_files = Dir["#{source_bins}/h-*"]
-  if bin_files.any?
-    FileUtils.cp(bin_files, dest_bin)
-    bin_files.each { |f| FileUtils.chmod(0755, File.join(dest_bin, File.basename(f))) }
-    puts "Installed #{bin_files.size} subcommands to #{dest_bin}"
-    bin_files.each { |f| puts "  - #{File.basename(f)}" }
-  else
-    puts "No subcommands found in #{source_bins}"
+require "pry"
+
+Hiiro.run(*ARGV, cwd: Dir.pwd, plugins: [:Tasks]) do
+  add_subcommand(:version) { |*args|
+    puts Hiiro::VERSION
+  }
+
+  add_subcommand(:pry) { |*args|
+    binding.pry
+  }
+
+  add_subcommand(:ping) { |*args|
+    puts "pong"
+  }
+
+  add_subcommand(:setup) do |*args|
+    gem_root = File.expand_path("../..", __FILE__)
+    source_plugins = File.join(gem_root, "plugins")
+    source_bins = File.join(gem_root, "bin")
+    dest_plugins = File.expand_path("~/.config/hiiro/plugins")
+    dest_bin = File.expand_path("~/bin")
+
+    FileUtils.mkdir_p(dest_plugins)
+    FileUtils.mkdir_p(dest_bin)
+
+    # Copy plugins
+    plugin_files = Dir["#{source_plugins}/*.rb"]
+    if plugin_files.any?
+      FileUtils.cp(plugin_files, dest_plugins)
+      puts "Installed #{plugin_files.size} plugins to #{dest_plugins}"
+      plugin_files.each { |f| puts "  - #{File.basename(f)}" }
+    else
+      puts "No plugins found in #{source_plugins}"
+    end
+
+    puts
+
+    # Copy bin scripts
+    bin_files = Dir["#{source_bins}/h-*"]
+    if bin_files.any?
+      FileUtils.cp(bin_files, dest_bin)
+      bin_files.each { |f| FileUtils.chmod(0755, File.join(dest_bin, File.basename(f))) }
+      puts "Installed #{bin_files.size} subcommands to #{dest_bin}"
+      bin_files.each { |f| puts "  - #{File.basename(f)}" }
+    else
+      puts "No subcommands found in #{source_bins}"
+    end
+
+    puts
+    puts "Setup complete! Make sure ~/bin is in your PATH."
   end
-
-  puts
-  puts "Setup complete! Make sure ~/bin is in your PATH."
 end
-
-hiiro.run

data/lib/hiiro/history/entry.rb

@@ -85,12 +85,13 @@ class Hiiro
       def oneline(index = nil)
         time_str = timestamp ? Time.parse(timestamp).strftime('%m/%d %H:%M') : ''
         prefix = index ? format('%3d  ', index) : ''
+        sha_str = git_sha ? git_sha[0..6] : '-------'
         branch_str = git_branch ? "[#{git_branch}]" : ''
         task_str = task ? "(#{task})" : ''
         cmd_str = cmd || description || ''
-        cmd_str = cmd_str[0..40] + '...' if cmd_str.length > 43
+        cmd_str = cmd_str[0..35] + '...' if cmd_str.length > 38
 
-        "#{prefix}#{time_str}  #{branch_str.ljust(20)}  #{task_str.ljust(15)}  #{cmd_str}"
+        "#{prefix}#{time_str}  #{sha_str}  #{branch_str.ljust(20)}  #{task_str.ljust(15)}  #{cmd_str}"
       end
 
       def full_display

data/lib/hiiro/history.rb

@@ -382,13 +382,13 @@ class Hiiro
     end
 
     def current_git_sha
-      git_helper.commit('HEAD', short: true)
+      git_helper.commit('HEAD')
     end
 
     def current_git_origin_sha
       branch = current_git_branch
       return nil unless branch
-      git_helper.commit("origin/#{branch}", short: true)
+      git_helper.commit("origin/#{branch}")
     end
 
     def current_git_worktree

data/lib/hiiro/prefix_matcher.rb

@@ -0,0 +1,110 @@
+class Hiiro
+  class PrefixMatcher
+    class << self
+      def find(items, prefix, key: nil, &block)
+        new(items, key, &block).find(prefix)
+      end
+
+      def find_all(items, prefix, key: nil, &block)
+        new(items, key, &block).find_all(prefix)
+      end
+
+      def resolve(items, prefix, key: nil, &block)
+        new(items, key, &block).resolve(prefix)
+      end
+
+      def find_path(items, prefix, key: nil, &block)
+        new(items, key, &block).find_path(prefix)
+      end
+
+      def find_all_paths(items, prefix, key: nil, &block)
+        new(items, key, &block).find_all_paths(prefix)
+      end
+
+      def resolve_path(items, prefix, key: nil, &block)
+        new(items, key, &block).resolve_path(prefix)
+      end
+    end
+
+    attr_reader :original_items, :key, :block
+
+    def initialize(items, key = nil, &block)
+      @original_items = items
+      @key = key
+      @block = block
+    end
+
+    def items(key = nil, &block)
+      if key.nil? && !block_given?
+        @items ||= original_items.map { |item| extract(item, @key, &@block) }
+      else
+        original_items.map { |item| extract(item, key, &block) }
+      end
+    end
+
+    def extracted_items(key = nil, &block)
+      original_items.zip(items(key, &block))
+    end
+
+    def find(prefix, key = nil, &block)
+      extracted_items(key, &block).find { |_, extracted| matches?(extracted, prefix) }&.first
+    end
+
+    def find_all(prefix, key = nil, &block)
+      extracted_items(key, &block).select { |_, extracted| matches?(extracted, prefix) }.map(&:first)
+    end
+
+    def resolve(prefix, key = nil, &block)
+      pairs = extracted_items(key, &block)
+
+      exact = pairs.find { |_, extracted| extracted == prefix }
+      return exact.first if exact
+
+      matches = pairs.select { |_, extracted| matches?(extracted, prefix) }
+      matches.one? ? matches.first.first : nil
+    end
+
+    def find_path(prefix, key = nil, &block)
+      matching_path_pairs(prefix, key, &block).first&.first
+    end
+
+    def find_all_paths(prefix, key = nil, &block)
+      matching_path_pairs(prefix, key, &block).map(&:first)
+    end
+
+    def resolve_path(prefix, key = nil, &block)
+      matches = matching_path_pairs(prefix, key, &block)
+      return nil if matches.empty?
+      return matches.first.first if matches.one?
+
+      exact = matches.find { |_, path| path == prefix }
+      exact&.first
+    end
+
+    private
+
+    def matching_path_pairs(prefix, key = nil, &block)
+      prefixes = prefix.to_s.split('/')
+
+      pairs = extracted_items(key, &block).map { |item, extracted|
+        [item, extracted.to_s.split('/')]
+      }
+
+      prefixes.each_with_index do |seg, i|
+        pairs = pairs.select { |_, path| path[i]&.start_with?(seg) }
+      end
+
+      pairs.map { |item, path| [item, path.join('/')] }
+    end
+
+    def matches?(item, prefix)
+      item.to_s.start_with?(prefix.to_s)
+    end
+
+    def extract(item, key = nil, &block)
+      return block.call(item) if block
+      return item.send(key) if key
+      item
+    end
+  end
+end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.54"
+  VERSION = "0.1.56"
 end

data/lib/hiiro.rb

@@ -3,6 +3,7 @@ require "yaml"
 require "shellwords"
 
 require_relative "hiiro/version"
+require_relative "hiiro/prefix_matcher"
 require_relative "hiiro/git"
 require_relative "hiiro/history"
 require_relative "hiiro/options"

data/plugins/pins.rb

@@ -54,15 +54,11 @@ module Pins
     end
 
     def find(partial)
-      pins.keys.map(&:to_s).find do |pin_name|
-        pin_name.start_with?(partial)
-      end
+      Hiiro::PrefixMatcher.find(pins.keys.map(&:to_s), partial)
     end
 
     def find_all(partial)
-      pins.keys.map(&:to_s).select do |pin_name|
-        pin_name.start_with?(partial)
-      end
+      Hiiro::PrefixMatcher.find_all(pins.keys.map(&:to_s), partial)
     end
 
     def remove(name)

data/plugins/tasks.rb

@@ -75,6 +75,8 @@ class Tree
 end
 
 class Task
+  HASH_METHODS = %i[name parent_name short_name session_name tree_name top_level? subtask?]
+
   attr_reader :name, :tree_name, :session_name
 
   def initialize(name:, tree: nil, session: nil, **_)
@@ -109,10 +111,7 @@ class Task
   end
 
   def to_h
-    h = { 'name' => name }
-    h['tree'] = tree_name if tree_name
-    h['session'] = session_name if session_name != name
-    h
+    HASH_METHODS.zip(HASH_METHODS.map{|m| send(m) }).to_h
   end
 end
 
@@ -169,6 +168,22 @@ class Environment
     @all_apps ||= config.apps
   end
 
+  def tree_matcher
+    @tree_matcher ||= Hiiro::PrefixMatcher.new(all_trees, :name)
+  end
+
+  def session_matcher
+    @session_matcher ||= Hiiro::PrefixMatcher.new(all_sessions, :name)
+  end
+
+  def app_matcher
+    @app_matcher ||= Hiiro::PrefixMatcher.new(all_apps, :name)
+  end
+
+  def task_matcher
+    @task_matcher ||= Hiiro::PrefixMatcher.new(all_tasks, :name)
+  end
+
   def task
     @task ||= begin
       s = session
@@ -191,36 +206,36 @@ class Environment
   def find_task(abbreviated)
     return nil if abbreviated.nil?
 
+    # Try path-based matching first (handles "parent/child" patterns)
     if abbreviated.include?('/')
-      parent_prefix, child_prefix = abbreviated.split('/', 2)
-      parent = all_tasks.select(&:top_level?).find { |t| t.name.start_with?(parent_prefix) }
-      return nil unless parent
-
-      subtask = all_tasks.select { |t| t.parent_name == parent.name }.find { |t| t.short_name.start_with?(child_prefix) }
-      return subtask if subtask
+      result = task_matcher.resolve_path(abbreviated)
+      return result if result
 
       # "main" refers to the parent task itself
-      return parent if 'main'.start_with?(child_prefix)
+      parent_prefix, child_prefix = abbreviated.split('/', 2)
+      if 'main'.start_with?(child_prefix)
+        return task_matcher.find(parent_prefix)
+      end
 
       nil
     else
-      all_tasks.find { |t| t.name.start_with?(abbreviated) }
+      task_matcher.find(abbreviated)
     end
   end
 
   def find_tree(abbreviated)
     return nil if abbreviated.nil?
-    all_trees.find { |t| t.name.start_with?(abbreviated) }
+    tree_matcher.find(abbreviated)
   end
 
   def find_session(abbreviated)
     return nil if abbreviated.nil?
-    all_sessions.find { |s| s.name.start_with?(abbreviated) }
+    session_matcher.find(abbreviated)
   end
 
   def find_app(abbreviated)
     return nil if abbreviated.nil?
-    all_apps.find { |a| a.name.start_with?(abbreviated) }
+    app_matcher.find(abbreviated)
   end
 end
 
@@ -228,89 +243,6 @@ class TaskManager
   TASKS_DIR = File.join(Dir.home, '.config', 'hiiro', 'tasks')
   APPS_FILE = File.join(Dir.home, '.config', 'hiiro', 'apps.yml')
 
-  class Config
-    attr_reader :tasks_file, :apps_file
-
-    def initialize(tasks_file: nil, apps_file: nil)
-      @tasks_file = tasks_file || File.join(TASKS_DIR, 'tasks.yml')
-      @apps_file = apps_file || APPS_FILE
-    end
-
-    def tasks
-      data = load_tasks
-      (data['tasks'] || []).map { |h| Task.new(**h.transform_keys(&:to_sym)) }
-    end
-
-    def apps
-      return [] unless File.exist?(apps_file)
-      data = YAML.safe_load_file(apps_file) || {}
-      data.map { |name, path| App.new(name: name, path: path) }
-    end
-
-    def save_task(task)
-      data = load_tasks
-      data['tasks'] ||= []
-      data['tasks'].reject! { |t| t['name'] == task.name }
-      data['tasks'] << task.to_h
-      save_tasks(data)
-    end
-
-    def remove_task(name)
-      data = load_tasks
-      data['tasks'] ||= []
-      data['tasks'].reject! { |t| t['name'] == name }
-      save_tasks(data)
-    end
-
-    private
-
-    def load_tasks
-      if File.exist?(tasks_file)
-        return YAML.safe_load_file(tasks_file) || { 'tasks' => [] }
-      end
-
-      # Load from individual task_*.yml files
-      task_files = Dir.glob(File.join(File.dirname(tasks_file), 'task_*.yml'))
-      if task_files.any?
-        tasks = task_files.map do |file|
-          short_name = File.basename(file, '.yml').sub(/^task_/, '')
-          data = YAML.safe_load_file(file) || {}
-          # Support parent key for subtasks, or infer from tree path
-          parent = data['parent']
-          if parent.nil? && data['tree']&.include?('/')
-            parent = data['tree'].split('/').first
-          end
-          name = parent ? "#{parent}/#{short_name}" : short_name
-          h = { 'name' => name }
-          h['tree'] = data['tree'] if data['tree']
-          h['session'] = data['session'] if data['session']
-          h
-        end
-        return { 'tasks' => tasks }
-      end
-
-      assignments_file = File.join(File.dirname(tasks_file), 'assignments.yml')
-      if File.exist?(assignments_file)
-        raw = YAML.safe_load_file(assignments_file) || {}
-        tasks = raw.map do |tree_path, task_name|
-          h = { 'name' => task_name, 'tree' => tree_path }
-          h['session'] = task_name if task_name.include?('/')
-          h
-        end
-        data = { 'tasks' => tasks }
-        save_tasks(data)
-        return data
-      end
-
-      { 'tasks' => [] }
-    end
-
-    def save_tasks(data)
-      FileUtils.mkdir_p(File.dirname(tasks_file))
-      File.write(tasks_file, YAML.dump(data))
-    end
-  end
-
   attr_reader :hiiro, :scope, :environment
 
   def initialize(hiiro, scope: :task, environment: nil)
@@ -344,18 +276,16 @@ class TaskManager
   def task_by_name(name)
     return slash_lookup(name) if name.include?('/')
 
-    tasks.find { |t|
-      match_name = (scope == :subtask) ? t.short_name : t.name
-      match_name.start_with?(name)
-    }
+    key = (scope == :subtask) ? :short_name : :name
+    Hiiro::PrefixMatcher.new(tasks, key).find(name)
   end
 
   def task_by_tree(tree_name)
-    tasks.find { |t| t.tree_name == tree_name }
+    environment.task_matcher.resolve(tree_name, :tree_name)
   end
 
   def task_by_session(session_name)
-    tasks.find { |t| t.session_name == session_name }
+    environment.task_matcher.resolve(session_name, :session_name)
   end
 
   def current_task
@@ -619,7 +549,7 @@ class TaskManager
       return
     end
 
-    matches = environment.all_apps.select { |a| a.name.start_with?(app_name) }
+    matches = environment.app_matcher.find_all(app_name)
 
     case matches.count
     when 0
@@ -693,7 +623,7 @@ class TaskManager
     tree = environment.find_tree(task.tree_name)
     tree_root = tree ? tree.path : File.join(WORK_DIR, task.tree_name)
 
-    matches = environment.all_apps.select { |a| a.name.start_with?(app_name) }
+    matches = environment.app_matcher.find_all(app_name)
 
     case matches.count
     when 0
@@ -742,14 +672,106 @@ class TaskManager
   def sk_select(items)
     Hiiro::Sk.select(items)
   end
+
+  class Config
+    attr_reader :tasks_file, :apps_file
+
+    def initialize(tasks_file: nil, apps_file: nil)
+      @tasks_file = tasks_file || File.join(TASKS_DIR, 'tasks.yml')
+      @apps_file = apps_file || APPS_FILE
+    end
+
+    def tasks
+      data = load_tasks
+      (data['tasks'] || []).map { |h| Task.new(**h.transform_keys(&:to_sym)) }
+    end
+
+    def apps
+      return [] unless File.exist?(apps_file)
+      data = YAML.safe_load_file(apps_file) || {}
+      data.map { |name, path| App.new(name: name, path: path) }
+    end
+
+    def save_task(task)
+      data = load_tasks
+      data['tasks'] ||= []
+      data['tasks'].reject! { |t| t['name'] == task.name }
+      data['tasks'] << task.to_h
+      save_tasks(data)
+    end
+
+    def remove_task(name)
+      data = load_tasks
+      data['tasks'] ||= []
+      data['tasks'].reject! { |t| t['name'] == name }
+      save_tasks(data)
+    end
+
+    private
+
+    def load_tasks
+      if File.exist?(tasks_file)
+        return YAML.safe_load_file(tasks_file) || { 'tasks' => [] }
+      end
+
+      # Load from individual task_*.yml files
+      task_files = Dir.glob(File.join(File.dirname(tasks_file), 'task_*.yml'))
+      if task_files.any?
+        tasks = task_files.map do |file|
+          short_name = File.basename(file, '.yml').sub(/^task_/, '')
+          data = YAML.safe_load_file(file) || {}
+          # Support parent key for subtasks, or infer from tree path
+          parent = data['parent']
+          if parent.nil? && data['tree']&.include?('/')
+            parent = data['tree'].split('/').first
+          end
+          name = parent ? "#{parent}/#{short_name}" : short_name
+          h = { 'name' => name }
+          h['tree'] = data['tree'] if data['tree']
+          h['session'] = data['session'] if data['session']
+          h
+        end
+        return { 'tasks' => tasks }
+      end
+
+      assignments_file = File.join(File.dirname(tasks_file), 'assignments.yml')
+      if File.exist?(assignments_file)
+        raw = YAML.safe_load_file(assignments_file) || {}
+        tasks = raw.map do |tree_path, task_name|
+          h = { 'name' => task_name, 'tree' => tree_path }
+          h['session'] = task_name if task_name.include?('/')
+          h
+        end
+        data = { 'tasks' => tasks }
+        save_tasks(data)
+        return data
+      end
+
+      { 'tasks' => [] }
+    end
+
+    def save_tasks(data)
+      FileUtils.mkdir_p(File.dirname(tasks_file))
+      File.write(tasks_file, YAML.dump(data))
+    end
+  end
 end
 
 module Tasks
   def self.load(hiiro)
     hiiro.load_plugin(Tmux)
+    attach_methods(hiiro)
     add_subcommands(hiiro)
   end
 
+  def self.attach_methods(hiiro)
+    hiiro.instance_eval do
+      def environment
+        @environment ||= Environment.current
+      end
+    end
+  end
+
   def self.add_subcommands(hiiro)
     hiiro.add_subcmd(:task) do |*args|
       mgr = TaskManager.new(hiiro, scope: :task)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.54
+  version: 0.1.56
 platform: ruby
 authors:
 - Joshua Toyota
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-07 00:00:00.000000000 Z
+date: 2026-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -79,6 +79,7 @@ files:
 - lib/hiiro/history.rb
 - lib/hiiro/history/entry.rb
 - lib/hiiro/options.rb
+- lib/hiiro/prefix_matcher.rb
 - lib/hiiro/sk.rb
 - lib/hiiro/version.rb
 - notes