hiiro 0.1.31 → 0.1.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9acf06495590129ec1870e030280f89addc30177e768c360aa8e6891d69ece7
-  data.tar.gz: afdc44652ae0ea1efbc107f8bd4b972c88477f07cf247665a66104859f49a0c2
+  metadata.gz: 33682128f00683ee714b4bc368dbcc2243544cf3c495063231ec95497ded5bc8
+  data.tar.gz: 8bfb329a9ec2f09a96e886c8a3ea3146ccb7a5a728ca5efc7a83509df3d578a0
 SHA512:
-  metadata.gz: 74d7b72bcb20c9cfdde0ef7c63d02d270f6f95fd05510fb5ff25f0543c4830f15418718f693fce532c8388f9c9a80851a9d13969646d75b187119f08d3d9cd64
-  data.tar.gz: 5f00c18b9bf9c47f8063a37dd6984bcbf97d7bdc4d06f06d918e1aa93aa48c316a14fd76301c56e029eafab2acacbc163f3e50c040b6d85f64217611554a56ae
+  metadata.gz: 6d4ad31db7afe3ca4ee5f7160e5004a086b8a5962908bc346bd30ca9a0c8a4d6948f1c699339d5103a14ea37b101b1beb8a515f17a154ec77e3b7a422cf8211e
+  data.tar.gz: b6f2348435f48f1ba9a2ce9b38cd7a6db4d5aefca7c32d8291e96ff6faf589d061f4b2d9838fc9643ff05988dfd9489680dd684e36a478f11203ceb8b40a311d

data/README.md

@@ -19,7 +19,7 @@ See [docs/](docs/) for detailed documentation on all subcommands.
 gem install hiiro
 
 # Install plugins and subcommands
-hiiro setup
+h setup
 ```
 
 This installs:
@@ -28,26 +28,15 @@ This installs:
 
 Ensure `~/bin` is in your `$PATH`.
 
-### Manual Installation
-
-```sh
-# Copy the main script
-cp bin/h ~/bin/h
-chmod +x ~/bin/h
-
-# Copy subcommands (optional)
-cp bin/h-* ~/bin/
-
-# Copy plugins (optional)
-mkdir -p ~/.config/hiiro/plugins
-cp plugins/*.rb ~/.config/hiiro/plugins/
-```
 
 ### Dependencies
 
 ```sh
 # For notify plugin (macOS)
 brew install terminal-notifier
+
+# For fuzzy-finder
+brew install sk
 ```
 
 ## Quick Start
@@ -56,14 +45,6 @@ brew install terminal-notifier
 # List available subcommands
 h
 
-# Edit the main h script
-h edit
-
-# Get paths
-h path      # Print current directory
-h ppath     # Print project root (git repo root + relative dir)
-h rpath     # Print relative directory from git root
-
 # Simple test
 h ping
 # => pong

data/TODO.md

@@ -0,0 +1,21 @@
+
+# To do...
+
+- [ ] move task/subtask back into a plugin
+  - [ ] have it add :task and :subtask subcommands to the instance of Hiiro
+    - [ ] they should init another hiiro instance with a `scope` value set
+    - [ ] if scope is :task, it looks at the whole world
+    - [ ] if the scope is :subtask, it scopes behavior to the current task
+    - [ ] redesign the yml structure for managing tasks
+
+```yml
+tasks:
+- name: some_name
+  parent_task: parent_task_name (if included it's a subtask)
+  tree: tree_name
+  root: repo_root/tree_name
+```
+- [ ] refactor task plugin to not be procedural AI slop
+- [ ] convert to js and using node
+- [ ] h-config {vim,zsh,tmux}
+- [ ] 

data/bin/g-pr

@@ -7,7 +7,7 @@ require "yaml"
 require "json"
 
 Hiiro.load_env
-hiiro = Hiiro.init(*ARGV, plugins: [Task, Tmux, Pins])
+hiiro = Hiiro.init(*ARGV, plugins: [OldTask, Tmux, Pins])
 
 class PRManager
   attr_reader :hiiro

data/bin/h-branch

@@ -5,7 +5,7 @@ require "fileutils"
 require "yaml"
 
 Hiiro.load_env
-hiiro = Hiiro.init(*ARGV, plugins: [Task])
+hiiro = Hiiro.init(*ARGV, plugins: [OldTask])
 
 class BranchManager
   attr_reader :hiiro

data/bin/{h-subtask → h-osubtask}

@@ -8,7 +8,7 @@ require "yaml"
 require "time"
 
 Hiiro.load_env
-hiiro = Hiiro.init(*ARGV, plugins: [Tmux, Task])
+hiiro = Hiiro.init(*ARGV, plugins: [Tmux, OldTask])
 
 tasks = hiiro.task_manager
 

data/bin/h-pr

@@ -7,7 +7,7 @@ require "yaml"
 require "json"
 
 Hiiro.load_env
-hiiro = Hiiro.init(*ARGV, plugins: [Task, Tmux, Pins])
+hiiro = Hiiro.init(*ARGV, plugins: [OldTask, Tmux, Pins])
 
 class PRManager
   attr_reader :hiiro

data/exe/h

@@ -3,7 +3,7 @@
 require "hiiro"
 require "fileutils"
 
-hiiro = Hiiro.init(*ARGV, cwd: Dir.pwd)
+hiiro = Hiiro.init(*ARGV, cwd: Dir.pwd, plugins: [Tasks])
 
 hiiro.add_subcommand(:version) { |*args|
   puts Hiiro::VERSION

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.31"
+  VERSION = "0.1.32"
 end

data/notes

@@ -0,0 +1,224 @@
+
+# Principles to use for refactoring
+
+- Separate data from behavior - create domain objects and any relevant value objects
+
+
+# Goals
+
+- same code to manage tasks/subtasks
+  - just scoped differently
+  - if scope is `:task` then consider all tasks, if scope is :subtask then only consider the tasks associated with the parent task
+- extract data objects
+  - so our procedures are human and easy af
+- more composable
+- separate presentation layer from the data
+
+
+# features we want
+
+- list tasks/subtasks
+- start a new one (wtree/tmux session)
+- switch between them
+- cd to an app's directory
+- stop a task
+- use yml files to track things
+
+turn @plugins/tasks.rb into a plugin similar to @plugins/task.rb
+
+but in add_subcommands(hiiro) i want to define 2 subtasks:
+1. `:task`
+2. `:subtask`
+
+both subcommands should initialize `Tasks.new(hiiro_instance, :task)` or
+`Tasks.new(hiiro_instance, :subtask)` if the subtask subcmd was called
+
+then uses the instance of Tasks to either do all the things that it needs to
+do... or just use it to get the data it needs, so that it can do the high level
+things like running tmux or git worktree commands.
+if it doesn't put those things inside Tasks, that would be better, so I can use
+these objects in other places like inside @bin/h-link
+
+use the following interface as a guide for how to organize things inside the
+new Tasks plugin
+
+# Interface
+
+class Environment
+  def self.current  # => Environment - makes new instance
+  def all_tasks     # => Task[] - call Task.all and memo cache the result
+  def all_sessions  # => Session[] - call TmuxSession.all and memo cache the result
+  def all_trees     # => Tree[] - call Tree.all and memo cache the result
+  def task          # => Task - move Task.current's behavior into this method, and memo cache the result
+  def session       # => Session - move TmuxSession.current here and memo cache the result
+  def tree          # => Tree - move Tree.current here and memo cache the result
+
+class Tree
+  attr_reader :path, :task, :session
+
+  def self.current  # => Tree - move to Environment#tree
+  def self.all      # => Tree[]
+
+class Session
+  attr_reader :name, :task
+
+  def self.current  # => Session - move to Environment#session
+  def self.all      # => Session[]
+
+class Task
+  attr_reader :name, :tree, :session, :parent, :subtasks
+
+  def self.current  # => Task - move to Environment#task
+  def self.all      # => Task[]
+
+class App
+  attr_reader :name, :path
+  def self.current      # => App[]
+  def self.all          # => App[]
+
+class Tasks
+  attr_reader :hiiro, :scope, :environment
+
+  def tasks                           # => Task[]
+  def subtasks(task)                  # => Task[]
+  def task_by_name(name)              # => Task
+  def task_by_tree(tree_name)         # => Task
+  def task_by_session(session_name)   # => Task
+  def current_task                    # => Task
+  def current_session                 # => Session
+  def current_tree                    # => Tree
+
+  def start_task(name, path)          # => Task
+  def switch_to_task(task)            # => nil
+  def stop_task(task)                 # => nil
+  def list(tasks)                     # => nil # print to screen
+  def cd_to_task(task)                # => nil
+  def cd_to_app(app_name)             # => nil
+
+  class Config
+    attr_reader :path
+
+
+
+
+# Follow-up prompts
+
+## i forget
+
+> when initializing an instance of `Task`...it shouldn't have a `parent_task` or `parent_name` kwarg.  it derive that context from the name given.  if the name has a `/` in it...then it
+is a subtask and the left side is the parent name and the right side is the subtask name.
+
+
+## lots of updates
+
+here are some updates i'd like to make:
+
+- all arguments received from the user should looking that object using
+    - something like `start_with?` so they can abbreviate the names of things to
+      match
+    - the only special one is task_name or subtask_name...if there is a `/` the
+      left side will do the abbreviation lookup on a parent name and the right
+      side will do a lookup on the subtask name
+        - you might want to add `#find_tree(abbreviated_name)` method to
+        Environment
+        - you might want to add `#find_session(abbreviated_name)` method to
+        Environment
+        - you might want to add `#find_app(abbreviated_name)` method to
+        Environment
+        - you might want to add `#find_task(abbreviated_name)` method to
+        Environment, where it does the left/right abbreviation lookups
+        - these new methods should help clean up and simplify all the lookups in
+          the other methods that typically use `.find{ ... }`
+      
+- get rid of methods like `apps_hash` and in the places that used it...
+    - just use the array returned from `#apps` and the attr_reader methods
+    for things like name and path or other values that there are attr_readers
+    for.
+    - always favor an instance method or attr_reader over exporting something
+    like hash
+
+- `#start_task` shouldn't take an optional `tree_path` keyword arg
+    - instead it should take an optional `app_name` kwarg and set the tmux
+    session's base directory to the matching app's configured directory
+      
+- `#switch_task` should also take an optional `app_name` kwarg. if a tmux
+    session already exists, just update the configs, associating the task 
+    with that app.  if the tmux session doesn't exist, use the app's path as the
+    base_directory.
+
+
+here's one fix i really want to get right.
+
+right now TasksPlugin has a dispatch method that uses a case statement to
+handle the subcommands.  what i'd like instead is for tasks plugin to initialize
+a new instance of `Hiiro` but instead of it receiving it's usual `*ARGV` as
+positional args, you should pass-in t `*hiiro.args` using the existing `hiiro`
+instance.  then for the new `Hiiro` instance...before you call `#run` on
+it...add each of the subcommands defined in the case statement using the
+`add_subcmd` method and have the block passed in be the handler for those
+subcommands
+
+so something like this:
+
+```ruby
+module TasksPlugin
+  # ...
+
+  def self.add_subcommands(hiiro)
+    hiiro.add_subcmd(:task) do |*args|
+      mgr = Tasks.new(hiiro, scope: :task)
+      new_hiiro = task_hiiro(hiiro, mgr)
+      new_hiiro.run
+    end
+
+    hiiro.add_subcmd(:subtask) do |*args|
+      mgr = Tasks.new(hiiro, scope: :subtask)
+      new_hiiro = task_hiiro(hiiro, mgr)
+      new_hiiro.run
+    end
+  end
+
+  def self.task_hiiro(parent_hiiro, mgr)
+    Hiiro.init(*parent_hiiro.args, mgr: mgr) do |task_hiiro|
+      task_hiiro.add_subcmd(:ls) do |*args|
+        # TODO: the logic to print out the task list based on mgr's values
+      end
+
+      task_hiiro.add_subcmd(:start) do |task_name, app_name=nil|
+        # TODO: the logic to print out the task list based on mgr's values
+        #       like:
+        mgr.start_task(task_name, app_name: app_name)
+      end
+
+      task_hiiro.add_subcmd(:switch) do |task_name, app_name=nil|
+        # TODO: the logic to print out the task list based on mgr's values
+        mgr.switch_to_task(task_name, app_name: app_name)
+
+        # but if you need to add logic, i would do it here...like:
+        task = mgr.find_task(task_name)
+
+        if task
+          # run cmds to switch to task here...
+        else
+          # print some msg like no task found
+        end
+      end
+
+      # ...
+    end
+  end
+
+  # ...
+end
+```
+
+## third prompt
+
+for things like listing and switching subtasks
+always consider the main/parent task as a potential subtask to switch to.
+for lookups, treat the task name as parent name and `main` as the subtask name
+so something like `nameofparent/main`
+
+
+
+

data/plugins/{task.rb → old_task.rb}

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-module Task
+module OldTask
   def self.load(hiiro)
     hiiro.load_plugin(Tmux)
     attach_methods(hiiro)
@@ -79,7 +79,7 @@ module Task
   def self.attach_methods(hiiro)
     hiiro.instance_eval do
       def task_manager
-        @task_manager ||= Task::TaskManager.new(self)
+        @task_manager ||= OldTask::TaskManager.new(self)
       end
     end
   end

data/plugins/tasks.rb

@@ -0,0 +1,813 @@
+require 'yaml'
+require 'fileutils'
+require 'open3'
+
+WORK_DIR = File.join(Dir.home, 'work')
+REPO_PATH = File.join(WORK_DIR, '.bare')
+
+class TmuxSession
+  attr_reader :name
+
+  def self.current
+    return nil unless ENV['TMUX']
+
+    name = `tmux display-message -p '#S'`.chomp
+    new(name)
+  end
+
+  def self.all
+    output = `tmux list-sessions -F '#S' 2>/dev/null`
+    output.lines(chomp: true).map { |name| new(name) }
+  end
+
+  def initialize(name)
+    @name = name
+  end
+
+  def ==(other)
+    other.is_a?(TmuxSession) && name == other.name
+  end
+
+  def to_s
+    name
+  end
+end
+
+class Tree
+  attr_reader :path, :head, :branch
+
+  def self.all(repo_path: REPO_PATH)
+    output = `git -C #{repo_path} worktree list --porcelain 2>/dev/null`
+
+    trees = []
+    current = nil
+
+    output.lines(chomp: true).each do |line|
+      case line
+      when /^worktree (.*)/
+        trees << new(**current) if current
+        current = { path: $1 }
+      when /^HEAD (.*)/
+        current[:head] = $1 if current
+      when /^branch refs\/heads\/(.*)/
+        current[:branch] = $1 if current
+      when 'bare'
+        current = nil
+      end
+    end
+
+    trees << new(**current) if current
+    trees
+  end
+
+  def initialize(path:, head: nil, branch: nil)
+    @path = path
+    @head = head
+    @branch = branch
+  end
+
+  def name
+    @name ||= if path.start_with?(WORK_DIR + '/')
+      path.sub(WORK_DIR + '/', '')
+    else
+      File.basename(path)
+    end
+  end
+
+  def match?(pwd = Dir.pwd)
+    pwd == path || pwd.start_with?(path + '/')
+  end
+
+  def detached?
+    branch.nil?
+  end
+
+  def ==(other)
+    other.is_a?(Tree) && path == other.path
+  end
+
+  def to_s
+    name
+  end
+end
+
+class Task
+  attr_reader :name, :tree_name, :session_name
+
+  def initialize(name:, tree: nil, session: nil, **_)
+    @name = name
+    @tree_name = tree
+    @session_name = session || name
+  end
+
+  def parent_name
+    return nil unless subtask?
+    name.split('/').first
+  end
+
+  def short_name
+    subtask? ? name.split('/', 2).last : name
+  end
+
+  def subtask?
+    name.include?('/')
+  end
+
+  def top_level?
+    !subtask?
+  end
+
+  def ==(other)
+    other.is_a?(Task) && name == other.name
+  end
+
+  def to_s
+    name
+  end
+
+  def to_h
+    h = { 'name' => name }
+    h['tree'] = tree_name if tree_name
+    h['session'] = session_name if session_name != name
+    h
+  end
+end
+
+class App
+  attr_reader :name, :relative_path
+
+  def initialize(name:, path:)
+    @name = name
+    @relative_path = path
+  end
+
+  def resolve(tree_root)
+    File.join(tree_root, relative_path)
+  end
+
+  def ==(other)
+    other.is_a?(App) && name == other.name
+  end
+
+  def to_s
+    name
+  end
+end
+
+class Environment
+  attr_reader :path
+
+  def self.current
+    new(path: Dir.pwd)
+  end
+
+  def initialize(path: Dir.pwd, config: nil)
+    @path = path
+    @config = config
+  end
+
+  def config
+    @config ||= TaskManager::Config.new
+  end
+
+  def all_tasks
+    @all_tasks ||= config.tasks
+  end
+
+  def all_sessions
+    @all_sessions ||= TmuxSession.all
+  end
+
+  def all_trees
+    @all_trees ||= Tree.all
+  end
+
+  def all_apps
+    @all_apps ||= config.apps
+  end
+
+  def task
+    @task ||= begin
+      s = session
+      t = tree
+      all_tasks.find { |task|
+        (s && task.session_name == s.name) ||
+          (t && task.tree_name == t.name)
+      }
+    end
+  end
+
+  def session
+    @session ||= TmuxSession.current
+  end
+
+  def tree
+    @tree ||= all_trees.find { |t| t.match?(path) }
+  end
+
+  def find_task(abbreviated)
+    return nil if abbreviated.nil?
+
+    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
+
+      # "main" refers to the parent task itself
+      return parent if 'main'.start_with?(child_prefix)
+
+      nil
+    else
+      all_tasks.find { |t| t.name.start_with?(abbreviated) }
+    end
+  end
+
+  def find_tree(abbreviated)
+    return nil if abbreviated.nil?
+    all_trees.find { |t| t.name.start_with?(abbreviated) }
+  end
+
+  def find_session(abbreviated)
+    return nil if abbreviated.nil?
+    all_sessions.find { |s| s.name.start_with?(abbreviated) }
+  end
+
+  def find_app(abbreviated)
+    return nil if abbreviated.nil?
+    all_apps.find { |a| a.name.start_with?(abbreviated) }
+  end
+end
+
+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
+
+      assignments_file = File.join(File.dirname(tasks_file), 'assignments.yml')
+      if File.exist?(assignments_file)
+        raw = YAML.safe_load_file(assignments_file) || {}
+        data = { 'tasks' => raw.map { |path, name| { 'name' => name, 'tree' => path } } }
+        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)
+    @hiiro = hiiro
+    @scope = scope
+    @environment = environment || Environment.current
+  end
+
+  def config
+    environment.config
+  end
+
+  # --- Scope-aware queries ---
+
+  def tasks
+    if scope == :subtask
+      parent = current_parent_task
+      return [] unless parent
+      main_task = Task.new(name: "#{parent.name}/main", tree: parent.tree_name, session: parent.session_name)
+      subtask_list = environment.all_tasks.select { |t| t.parent_name == parent.name }
+      [main_task, *subtask_list]
+    else
+      environment.all_tasks.select(&:top_level?)
+    end
+  end
+
+  def subtasks(task)
+    environment.all_tasks.select { |t| t.parent_name == task.name }
+  end
+
+  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)
+    }
+  end
+
+  def task_by_tree(tree_name)
+    tasks.find { |t| t.tree_name == tree_name }
+  end
+
+  def task_by_session(session_name)
+    tasks.find { |t| t.session_name == session_name }
+  end
+
+  def current_task
+    environment.task
+  end
+
+  def current_session
+    environment.session
+  end
+
+  def current_tree
+    environment.tree
+  end
+
+  # --- Actions ---
+
+  def start_task(name, app_name: nil)
+    existing = task_by_name(name)
+    if existing
+      puts "Task '#{existing.name}' already exists. Switching..."
+      switch_to_task(existing, app_name: app_name)
+      return
+    end
+
+    task_name = scope == :subtask ? "#{current_parent_task.name}/#{name}" : name
+    subtree_name = scope == :subtask ? "#{current_parent_task.name}/#{name}" : "#{name}/main"
+
+    target_path = File.join(WORK_DIR, subtree_name)
+
+    available = find_available_tree
+    if available
+      puts "Renaming worktree '#{available.name}' to '#{subtree_name}'..."
+      FileUtils.mkdir_p(File.dirname(target_path))
+      unless system('git', '-C', REPO_PATH, 'worktree', 'move', available.path, target_path)
+        puts "ERROR: Failed to rename worktree"
+        return
+      end
+    else
+      puts "Creating new worktree '#{subtree_name}'..."
+      FileUtils.mkdir_p(File.dirname(target_path))
+      unless system('git', '-C', REPO_PATH, 'worktree', 'add', '--detach', target_path)
+        puts "ERROR: Failed to create worktree"
+        return
+      end
+    end
+
+    session_name = task_name
+    task = Task.new(name: task_name, tree: subtree_name, session: session_name)
+    config.save_task(task)
+
+    base_dir = target_path
+    if app_name
+      app = environment.find_app(app_name)
+      base_dir = app.resolve(target_path) if app
+    end
+
+    Dir.chdir(base_dir)
+    hiiro.start_tmux_session(session_name)
+
+    puts "Started task '#{task_name}' in worktree '#{subtree_name}'"
+  end
+
+  def switch_to_task(task, app_name: nil)
+    unless task
+      puts "Task not found"
+      return
+    end
+
+    tree = environment.find_tree(task.tree_name)
+    tree_path = tree ? tree.path : File.join(WORK_DIR, task.tree_name)
+
+    session_name = task.session_name
+    session_exists = system('tmux', 'has-session', '-t', session_name, err: File::NULL)
+
+    if session_exists
+      hiiro.start_tmux_session(session_name)
+    else
+      base_dir = tree_path
+      if app_name
+        app = environment.find_app(app_name)
+        base_dir = app.resolve(tree_path) if app
+      end
+
+      if Dir.exist?(base_dir)
+        Dir.chdir(base_dir)
+        hiiro.start_tmux_session(session_name)
+      else
+        puts "ERROR: Path '#{base_dir}' does not exist"
+        return
+      end
+    end
+
+    puts "Switched to '#{task.name}'"
+  end
+
+  def stop_task(task)
+    unless task
+      puts "Task not found"
+      return
+    end
+
+    config.remove_task(task.name)
+    # Also remove any subtasks
+    subtasks(task).each { |st| config.remove_task(st.name) }
+
+    puts "Stopped task '#{task.name}' (worktree available for reuse)"
+  end
+
+  def list
+    items = tasks
+    if items.empty?
+      puts scope == :subtask ? "No subtasks found" : "No tasks found"
+      puts "Use 'h #{scope} start NAME' to create one."
+      return
+    end
+
+    current = current_task
+    label = scope == :subtask ? "Subtasks" : "Tasks"
+    if scope == :subtask && current
+      parent = current_parent_task
+      label = "Subtasks of '#{parent&.name}'" if parent
+    end
+
+    puts "#{label}:"
+    puts
+
+    items.each do |task|
+      marker = (current && current.name == task.name) ? "*" : " "
+      tree = environment.find_tree(task.tree_name)
+      branch = tree&.branch || (tree&.detached? ? '(detached)' : nil)
+      branch_str = branch ? "  [#{branch}]" : ""
+
+      display_name = scope == :subtask ? task.short_name : task.name
+      puts format("%s %-25s  tree: %-20s%s", marker, display_name, task.tree_name || '(none)', branch_str)
+
+      # Show subtask count for top-level tasks
+      if scope == :task
+        subs = subtasks(task)
+        subs.each do |st|
+          sub_marker = (current && current.name == st.name) ? "*" : " "
+          sub_tree = environment.find_tree(st.tree_name)
+          sub_branch = sub_tree&.branch || (sub_tree&.detached? ? '(detached)' : nil)
+          sub_branch_str = sub_branch ? "  [#{sub_branch}]" : ""
+          padding = " " * task.name.length
+          puts format("%s %s/%-*s  tree: %-20s%s", sub_marker, padding, 25 - task.name.length - 1, st.short_name, st.tree_name || '(none)', sub_branch_str)
+        end
+      end
+    end
+
+    available = environment.all_trees.reject { |t|
+      environment.all_tasks.any? { |task| task.tree_name == t.name }
+    }
+
+    if available.any?
+      puts
+      available.each do |tree|
+        branch_str = tree.branch ? "  [#{tree.branch}]" : tree.detached? ? "  [(detached)]" : ""
+        puts format("  %-25s  (available)%s", tree.name, branch_str)
+      end
+    end
+  end
+
+  def status
+    task = current_task
+    unless task
+      puts "Not currently in a task session"
+      return
+    end
+
+    puts "Task: #{task.name}"
+    puts "Worktree: #{task.tree_name}"
+    tree = environment.find_tree(task.tree_name)
+    puts "Path: #{tree&.path || '(unknown)'}"
+    puts "Session: #{task.session_name}"
+    puts "Parent: #{task.parent_name}" if task.subtask?
+  end
+
+  def save
+    task = current_task
+    unless task
+      puts "ERROR: Not currently in a task session"
+      return
+    end
+
+    windows = capture_tmux_windows(task.session_name)
+    puts "Saved task '#{task.name}' state (#{windows.count} windows)"
+  end
+
+  def open_app(app_name)
+    task = current_task
+    unless task
+      puts "ERROR: Not currently in a task session"
+      return
+    end
+
+    result = resolve_app(app_name, task)
+    return unless result
+
+    resolved_name, app_path = result
+    system('tmux', 'new-window', '-n', resolved_name, '-c', app_path)
+    puts "Opened '#{resolved_name}' in new window (#{app_path})"
+  end
+
+  def list_apps
+    apps = environment.all_apps
+    if apps.any?
+      puts "Configured apps:"
+      puts
+      apps.each do |app|
+        puts format("  %-20s => %s", app.name, app.relative_path)
+      end
+    else
+      puts "No apps configured."
+      puts "Create #{APPS_FILE} with format:"
+      puts "  app_name: relative/path/from/repo"
+    end
+  end
+
+  def cd_to_task(task)
+    unless task
+      puts "Task not found"
+      return
+    end
+
+    tree = environment.find_tree(task.tree_name)
+    path = tree ? tree.path : File.join(WORK_DIR, task.tree_name)
+    send_cd(path)
+  end
+
+  def cd_to_app(app_name = nil)
+    task = current_task
+    unless task
+      puts "ERROR: Not currently in a task session"
+      return
+    end
+
+    if app_name.nil? || app_name.empty?
+      tree = environment.find_tree(task.tree_name)
+      send_cd(tree&.path || File.join(WORK_DIR, task.tree_name))
+      return
+    end
+
+    result = resolve_app(app_name, task)
+    return unless result
+
+    _resolved_name, app_path = result
+    send_cd(app_path)
+  end
+
+  def app_path(app_name = nil)
+    task = current_task
+    tree_root = if task
+      tree = environment.find_tree(task.tree_name)
+      tree&.path || File.join(WORK_DIR, task.tree_name)
+    else
+      `git rev-parse --show-toplevel`.strip
+    end
+
+    if app_name.nil?
+      print tree_root
+      return
+    end
+
+    matches = environment.all_apps.select { |a| a.name.start_with?(app_name) }
+
+    case matches.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)
+    else
+      puts "Multiple matches found:"
+      matches.each { |a| puts format("  %-20s => %s", a.name, a.relative_path) }
+    end
+  end
+
+  def help
+    scope_name = scope.to_s
+    puts "Usage: h #{scope_name} <subcommand> [args]"
+    puts
+    puts "Subcommands:"
+    puts "  list, ls              List #{scope_name}s"
+    puts "  start NAME [APP]      Start a new #{scope_name}"
+    puts "  switch [NAME]         Switch to a #{scope_name} (interactive if no name)"
+    puts "  app [APP_NAME]        Open app in new tmux window (interactive if no name)"
+    puts "  apps                  List configured apps"
+    puts "  cd [APP_NAME]         Change directory to app"
+    puts "  path [APP_NAME]       Print app path"
+    puts "  status, st            Show current #{scope_name} status"
+    puts "  save                  Save current session state"
+    puts "  stop [NAME]           Stop a #{scope_name} (interactive if no name)"
+  end
+
+  # --- Interactive selection with sk ---
+
+  def select_task_interactive(prompt = nil)
+    names = tasks.map { |t| scope == :subtask ? t.short_name : t.name }
+    return nil if names.empty?
+
+    sk_select(names)
+  end
+
+  # --- Private helpers ---
+
+  private
+
+  def slash_lookup(input)
+    environment.find_task(input)
+  end
+
+  def current_parent_task
+    task = current_task
+    return nil unless task
+
+    if task.subtask?
+      environment.find_task(task.parent_name)
+    else
+      task
+    end
+  end
+
+  def find_available_tree
+    assigned_tree_names = environment.all_tasks.map(&:tree_name)
+    environment.all_trees.find { |tree| !assigned_tree_names.include?(tree.name) }
+  end
+
+  def resolve_app(app_name, task)
+    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) }
+
+    case matches.count
+    when 0
+      # Fallback: directory discovery
+      exact = File.join(tree_root, app_name)
+      return [app_name, exact] if Dir.exist?(exact)
+
+      nested = File.join(tree_root, app_name, app_name)
+      return [app_name, nested] if Dir.exist?(nested)
+
+      puts "ERROR: App '#{app_name}' not found"
+      list_apps
+      nil
+    when 1
+      app = matches.first
+      [app.name, app.resolve(tree_root)]
+    else
+      exact = matches.find { |a| a.name == app_name }
+      if exact
+        [exact.name, exact.resolve(tree_root)]
+      else
+        puts "ERROR: '#{app_name}' matches multiple apps:"
+        matches.each { |a| puts "  #{a.name}" }
+        nil
+      end
+    end
+  end
+
+  def send_cd(path)
+    pane = ENV['TMUX_PANE']
+    if pane
+      system('tmux', 'send-keys', '-t', pane, "cd #{path}\n")
+    else
+      system('tmux', 'send-keys', "cd #{path}\n")
+    end
+  end
+
+  def capture_tmux_windows(session)
+    output = `tmux list-windows -t #{session} -F '\#{window_index}:\#{window_name}:\#{pane_current_path}' 2>/dev/null`
+    output.lines.map(&:strip).map { |line|
+      idx, name, path = line.split(':')
+      { 'index' => idx, 'name' => name, 'path' => path }
+    }
+  end
+
+  def sk_select(items)
+    selected, status = Open3.capture2('sk', stdin_data: items.join("\n"))
+    return selected.strip if status.success? && !selected.strip.empty?
+    nil
+  end
+end
+
+module Tasks
+  def self.load(hiiro)
+    hiiro.load_plugin(Tmux)
+    add_subcommands(hiiro)
+  end
+
+  def self.add_subcommands(hiiro)
+    hiiro.add_subcmd(:task) do |*args|
+      mgr = TaskManager.new(hiiro, scope: :task)
+      task_hiiro = Tasks.build_hiiro(hiiro, mgr)
+      task_hiiro.run
+    end
+
+    hiiro.add_subcmd(:subtask) do |*args|
+      mgr = TaskManager.new(hiiro, scope: :subtask)
+      task_hiiro = Tasks.build_hiiro(hiiro, mgr)
+      task_hiiro.run
+    end
+  end
+
+  def self.build_hiiro(parent_hiiro, mgr)
+    Hiiro.init(*parent_hiiro.args, mgr: mgr) do |h|
+      h.add_subcmd(:list) { mgr.list }
+      h.add_subcmd(:ls) { mgr.list }
+
+      h.add_subcmd(:start) do |task_name, app_name=nil|
+        mgr.start_task(task_name, app_name: app_name)
+      end
+
+      h.add_subcmd(:switch) do |task_name=nil, app_name=nil|
+        if task_name.nil?
+          task_name = mgr.select_task_interactive
+          return unless task_name
+        end
+        task = mgr.task_by_name(task_name)
+        mgr.switch_to_task(task, app_name: app_name)
+      end
+
+      h.add_subcmd(:app) do |app_name=nil|
+        if app_name.nil?
+          names = mgr.environment.all_apps.map(&:name)
+          app_name = mgr.send(:sk_select, names)
+          return unless app_name
+        end
+        mgr.open_app(app_name)
+      end
+
+      h.add_subcmd(:apps) { mgr.list_apps }
+
+      h.add_subcmd(:cd) do |app_name=nil|
+        mgr.cd_to_app(app_name)
+      end
+
+      h.add_subcmd(:path) do |app_name=nil|
+        mgr.app_path(app_name)
+      end
+
+      h.add_subcmd(:status) { mgr.status }
+      h.add_subcmd(:st) { mgr.status }
+
+      h.add_subcmd(:save) { mgr.save }
+
+      h.add_subcmd(:stop) do |task_name=nil|
+        if task_name.nil?
+          task_name = mgr.select_task_interactive
+          return unless task_name
+        end
+        task = mgr.task_by_name(task_name)
+        mgr.stop_task(task)
+      end
+
+      h.add_subcmd(:edit) do
+        system(ENV['EDITOR'] || 'nvim', __FILE__)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.31
+  version: 0.1.32
 platform: ruby
 authors:
 - Joshua Toyota
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-31 00:00:00.000000000 Z
+date: 2026-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -38,6 +38,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
 - bin/g-pr
 - bin/h
 - bin/h-branch
@@ -49,6 +50,8 @@ files:
 - bin/h-link
 - bin/h-mic
 - bin/h-note
+- bin/h-osubtask
+- bin/h-otask
 - bin/h-pane
 - bin/h-plugin
 - bin/h-pr
@@ -59,8 +62,6 @@ files:
 - bin/h-serve
 - bin/h-session
 - bin/h-sha
-- bin/h-subtask
-- bin/h-task
 - bin/h-video
 - bin/h-vim
 - bin/h-window
@@ -78,10 +79,12 @@ files:
 - lib/hiiro/history.rb
 - lib/hiiro/version.rb
 - links.backup.yml
+- notes
 - plugins/notify.rb
+- plugins/old_task.rb
 - plugins/pins.rb
 - plugins/project.rb
-- plugins/task.rb
+- plugins/tasks.rb
 - plugins/tmux.rb
 - script/compare
 - script/install