hiiro 0.1.55 → 0.1.57

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ef7a585109b14b6a8de8f7036b8d0099c1abbee33569c55436dcb51ac4c1905
-  data.tar.gz: 0f20d4397f16fd0b4f67a3ee7485d9ee8583a5e96d7b2352c6bbcd9fb0dc1329
+  metadata.gz: 7f55785ca9b54838e9b0e0eefe8e1e829f85ad1b1d9a1ed6b961305b847f1828
+  data.tar.gz: cda5ec5bdc86b4210e4870d88bca437c9cc7dbac3857ae3e264a66ba0b054675
 SHA512:
-  metadata.gz: 8b6579c8c352aeafa41d6e066956ff56a29c17acd41fca0825f6ac35555cca1db9a726e83e150f28f2c938987e7fd1d35dc424e817c1cc0b1f1f6d078858ab93
-  data.tar.gz: 958d0c9c18f69e90578941f90457865eec33492b5bf83594c3fd8dd5d0d4e2cb30aced8e6535246729043fe3248e2f242731b63d08dacf8168133afe58975dc3
+  metadata.gz: 8d8e719178da0355245154216264edb4c292fb5ccc62dc561e8529bf7b67f4a94d85a5db3516e1406f5cf7464f61454dc3c07f7dc26530a44a895577b7082c12
+  data.tar.gz: 28a570aba442cb90419feaf3edd4ef4135773fc2f971401df942bb09617f17c7466c3ba32dbfc2edd1849895d973cdada07f80b8edd2932685e8f21bc00f29d4

data/Rakefile

@@ -1,3 +1,10 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
 
-task default: :build
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

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).matches.map(&:item) }.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/hiiro.gemspec

@@ -27,4 +27,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "pry", "~> 0.14"
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
 end

data/lib/hiiro/prefix_matcher.rb

@@ -0,0 +1,241 @@
+class Hiiro
+  class PrefixMatcher
+    class Item
+      attr_reader :item, :extracted_item, :key, :block
+
+      def initialize(item:, extracted_item:, key: nil, block: nil)
+        @item = item
+        @extracted_item = extracted_item
+        @key = key
+        @block = block
+      end
+    end
+
+    class Result
+      attr_reader :matcher, :all_items, :key, :block, :prefix
+
+      def initialize(matcher:, all_items:, prefix:, key: nil, block: nil)
+        @matcher = matcher
+        @all_items = all_items
+        @prefix = prefix
+        @key = key
+        @block = block
+      end
+
+      def matches
+        @matches ||= all_items.select { |item| item.extracted_item.to_s.start_with?(prefix.to_s) }
+      end
+
+      def count
+        matches.count
+      end
+
+      def ambiguous?
+        count > 1
+      end
+
+      def exact_match
+        all_items.find { |item| item.extracted_item == prefix }
+      end
+
+      def match
+        one? ? matches.first : nil
+      end
+
+      def match?
+        matches.any?
+      end
+
+      def exact?
+        !exact_match.nil?
+      end
+
+      def one?
+        count == 1
+      end
+
+      # Returns item for resolve semantics: exact match, or single match, otherwise nil
+      def resolved
+        exact_match || match
+      end
+
+      # Returns the first matching item (for find semantics)
+      def first
+        matches.first
+      end
+    end
+
+    class PathResult
+      attr_reader :matcher, :all_items, :key, :block, :prefix
+
+      def initialize(matcher:, all_items:, prefix:, key: nil, block: nil)
+        @matcher = matcher
+        @all_items = all_items
+        @prefix = prefix
+        @key = key
+        @block = block
+      end
+
+      def matches
+        @matches ||= begin
+          prefixes = prefix.to_s.split('/')
+
+          items_with_paths = all_items.map { |item|
+            [item, item.extracted_item.to_s.split('/')]
+          }
+
+          prefixes.each_with_index do |seg, i|
+            items_with_paths = items_with_paths.select { |_, path| path[i]&.start_with?(seg) }
+          end
+
+          items_with_paths.map(&:first)
+        end
+      end
+
+      def count
+        matches.count
+      end
+
+      def ambiguous?
+        count > 1
+      end
+
+      def exact_match
+        all_items.find { |item| item.extracted_item == prefix }
+      end
+
+      def match
+        one? ? matches.first : nil
+      end
+
+      def match?
+        matches.any?
+      end
+
+      def exact?
+        !exact_match.nil?
+      end
+
+      def one?
+        count == 1
+      end
+
+      # Returns item for resolve semantics: exact match, or single match, otherwise nil
+      def resolved
+        exact_match || match
+      end
+
+      # Returns the first matching item (for find semantics)
+      def first
+        matches.first
+      end
+    end
+
+    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 all_items(key = nil, &block)
+      use_key = key.nil? && !block_given? ? @key : key
+      use_block = key.nil? && !block_given? ? @block : block
+
+      @all_items_cache ||= {}
+      cache_key = [use_key, use_block].hash
+
+      @all_items_cache[cache_key] ||= original_items.map { |item|
+        Item.new(
+          item: item,
+          extracted_item: extract(item, use_key, &use_block),
+          key: use_key,
+          block: use_block
+        )
+      }
+    end
+
+    def search(prefix, key = nil, &block)
+      Result.new(
+        matcher: self,
+        all_items: all_items(key, &block),
+        prefix: prefix,
+        key: key || @key,
+        block: block || @block
+      )
+    end
+
+    def find(prefix, key = nil, &block)
+      search(prefix, key, &block)
+    end
+
+    def find_all(prefix, key = nil, &block)
+      search(prefix, key, &block)
+    end
+
+    def resolve(prefix, key = nil, &block)
+      search(prefix, key, &block)
+    end
+
+    def find_path(prefix, key = nil, &block)
+      search_path(prefix, key, &block)
+    end
+
+    def find_all_paths(prefix, key = nil, &block)
+      search_path(prefix, key, &block)
+    end
+
+    def resolve_path(prefix, key = nil, &block)
+      search_path(prefix, key, &block)
+    end
+
+    def search_path(prefix, key = nil, &block)
+      PathResult.new(
+        matcher: self,
+        all_items: all_items(key, &block),
+        prefix: prefix,
+        key: key || @key,
+        block: block || @block
+      )
+    end
+
+    private
+
+    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.55"
+  VERSION = "0.1.57"
 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

@@ -53,27 +53,27 @@ module Pins
       value
     end
 
+    def search(partial)
+      Hiiro::PrefixMatcher.find(pins.keys.map(&:to_s), partial)
+    end
+
     def find(partial)
-      pins.keys.map(&:to_s).find do |pin_name|
-        pin_name.start_with?(partial)
-      end
+      search(partial).match&.item
     end
 
     def find_all(partial)
-      pins.keys.map(&:to_s).select do |pin_name|
-        pin_name.start_with?(partial)
-      end
+      search(partial).matches.map(&:item)
     end
 
     def remove(name)
-      all_matches = find_all(name)
+      result = search(name)
 
-      if all_matches.count > 1
-        puts "Unable to remove pin.  Multiple matches: #{all_matches.inspect}"
+      if result.ambiguous?
+        puts "Unable to remove pin.  Multiple matches: #{result.matches.map(&:item).inspect}"
         return
       end
 
-      pin_name = all_matches.first
+      pin_name = result.match&.item
 
       pins.delete(pin_name.to_s)
     end

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.resolved&.item if result.match?
 
       # "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).first&.item
+      end
 
       nil
     else
-      all_tasks.find { |t| t.name.start_with?(abbreviated) }
+      task_matcher.find(abbreviated).first&.item
     end
   end
 
   def find_tree(abbreviated)
     return nil if abbreviated.nil?
-    all_trees.find { |t| t.name.start_with?(abbreviated) }
+    tree_matcher.find(abbreviated).first&.item
   end
 
   def find_session(abbreviated)
     return nil if abbreviated.nil?
-    all_sessions.find { |s| s.name.start_with?(abbreviated) }
+    session_matcher.find(abbreviated).first&.item
   end
 
   def find_app(abbreviated)
     return nil if abbreviated.nil?
-    all_apps.find { |a| a.name.start_with?(abbreviated) }
+    app_matcher.find(abbreviated).first&.item
   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).first&.item
   end
 
   def task_by_tree(tree_name)
-    tasks.find { |t| t.tree_name == tree_name }
+    environment.task_matcher.resolve(tree_name, :tree_name).resolved&.item
   end
 
   def task_by_session(session_name)
-    tasks.find { |t| t.session_name == session_name }
+    environment.task_matcher.resolve(session_name, :session_name).resolved&.item
   end
 
   def current_task
@@ -619,19 +549,19 @@ class TaskManager
       return
     end
 
-    matches = environment.all_apps.select { |a| a.name.start_with?(app_name) }
+    result = environment.app_matcher.find_all(app_name)
 
-    case matches.count
+    case result.count
     when 0
       puts "ERROR: No matches found"
       puts
       puts "Possible Apps:"
       environment.all_apps.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
     when 1
-      print matches.first.resolve(tree_root)
+      print result.first.item.resolve(tree_root)
     else
       puts "Multiple matches found:"
-      matches.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
+      result.matches.each { |m| puts format("  %-20s => %s", m.item.name, m.item.relative_path) }
     end
   end
 
@@ -693,9 +623,9 @@ 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) }
+    result = environment.app_matcher.find_all(app_name)
 
-    case matches.count
+    case result.count
     when 0
       # Fallback: directory discovery
       exact = File.join(tree_root, app_name)
@@ -708,15 +638,15 @@ class TaskManager
       list_apps
       nil
     when 1
-      app = matches.first
+      app = result.first.item
       [app.name, app.resolve(tree_root)]
     else
-      exact = matches.find { |a| a.name == app_name }
+      exact = result.matches.find { |m| m.item.name == app_name }
       if exact
-        [exact.name, exact.resolve(tree_root)]
+        [exact.item.name, exact.item.resolve(tree_root)]
       else
         puts "ERROR: '#{app_name}' matches multiple apps:"
-        matches.each { |a| puts "  #{a.name}" }
+        result.matches.each { |m| puts "  #{m.item.name}" }
         nil
       end
     end
@@ -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.transform_keys(&:to_s)
+      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)

data/script/test

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+bundle exec rake test "$@"
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.55
+  version: 0.1.57
 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
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 description: Build multi-command CLI tools with subcommand dispatch, abbreviation
   matching, and a plugin system. Similar to git or docker command structure.
 email:
@@ -79,6 +107,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
@@ -91,6 +120,7 @@ files:
 - script/install
 - script/publish
 - script/sync
+- script/test
 - script/update
 homepage: https://github.com/unixsuperhero/hiiro
 licenses: