hiiro 0.1.30 → 0.1.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ed8afa7ccba684e9508ee61648511cd08bc3ae84d74b43966a1b53d421f6b05
-  data.tar.gz: 3fc69daaad45903fda5a0123cecc0170698e35fdf0f130a78f8f8b05d17876fe
+  metadata.gz: 33682128f00683ee714b4bc368dbcc2243544cf3c495063231ec95497ded5bc8
+  data.tar.gz: 8bfb329a9ec2f09a96e886c8a3ea3146ccb7a5a728ca5efc7a83509df3d578a0
 SHA512:
-  metadata.gz: a1dded26ad1d42ca16d2cf50cb2d2385eb1d4bcf02215e47b655a6eb36a2a1e37bb91f80ca378691c85ca1226513806ab6baa4c9dd26dc140e1208228c31de8c
-  data.tar.gz: 1b1510771c5fae9c2bf7210a65d100163d1446e3a2fef43d7af524cb32440783ca2b7234d00563a66fc62510bbf3a92dbe2c6891e64e91747d5d5aec72910b6b
+  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
 
@@ -16,7 +16,7 @@ hiiro.add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }
 hiiro.add_subcmd(:list) { tasks.list_subtasks }
 hiiro.add_subcmd(:ls) { tasks.list_subtasks }
 hiiro.add_subcmd(:new) { |subtask_name| tasks.new_subtask(subtask_name) }
-hiiro.add_subcmd(:switch) { |subtask_name| tasks.switch_subtask(subtask_name) }
+hiiro.add_subcmd(:switch) { |subtask_name=nil| tasks.switch_subtask(subtask_name) }
 hiiro.add_subcmd(:app) { |app_name| tasks.subtask_open_app(app_name) }
 hiiro.add_subcmd(:path) { |app_name=nil| tasks.subtask_app_path(app_name) }
 hiiro.add_subcmd(:cd) { |*args| tasks.subtask_cd_app(*args) }

data/bin/{h-task → h-otask}

@@ -44,23 +44,55 @@ class TaskManager
     active, available = trees.partition { |tree_name| task_for_tree(tree_name) }
     sessions = tmux_sessions
 
+    # Group active trees by parent task
+    groups = {}
     active.each do |tree_name|
       task = task_for_tree(tree_name)
-      marker = (current && current[:tree] == tree_name) ? "*" : " "
-
-      # Check if there's a tmux session for this task
-      session_name = session_name_for(task)
-      has_session = sessions.include?(session_name)
-      session_marker = has_session ? "+" : " "
-      session_info = has_session ? " (#{session_name})" : ""
-
-      puts format("%s%s %-20s => %s%s", marker, session_marker, tree_name, task, session_info)
+      parent = task.include?('/') ? task.split('/').first : task
+      groups[parent] ||= []
+      groups[parent] << { tree: tree_name, task: task }
+    end
+
+    first_group = true
+    groups.each do |parent, entries|
+      puts unless first_group
+      first_group = false
+
+      # Sort so the main entry (parent itself or parent/main) comes first
+      entries.sort_by! { |e| e[:task] == parent || e[:task].end_with?('/main') ? 0 : 1 }
+
+      entries.each_with_index do |entry, i|
+        tree_name = entry[:tree]
+        task = entry[:task]
+        marker = (current && current[:tree] == tree_name) ? "*" : " "
+        branch = worktree_branch(tree_name)
+        branch_str = branch ? "  [#{branch}]" : ""
+
+        # Check if there's a tmux session for this task
+        session_name = session_name_for(task)
+        has_session = sessions.include?(session_name)
+        session_marker = has_session ? "+" : " "
+
+        if i == 0
+          # Parent task line
+          display_name = parent
+          puts format("%s%s %s%s", marker, session_marker, display_name, branch_str)
+        else
+          # Subtask line: align /child_name under the parent name
+          child_name = task.include?('/') ? task.split('/', 2).last : task
+          padding = " " * parent.length
+          puts format("%s%s %s/%s%s", marker, session_marker, padding, child_name, branch_str)
+        end
+      end
     end
 
-    puts if active.any? && available.any?
-
-    available.each do |tree_name|
-      puts format("   %-20s    (available)", tree_name)
+    if available.any?
+      puts
+      available.each do |tree_name|
+        branch = worktree_branch(tree_name)
+        branch_str = branch ? "  [#{branch}]" : ""
+        puts format("   %-20s  (available)%s", tree_name, branch_str)
+      end
     end
 
     # List tmux sessions without associated tasks
@@ -415,11 +447,11 @@ class TaskManager
     worktree_info.keys.sort
   end
 
-  # Parse git worktree list output into { name => path } hash
-  def worktree_info
-    @worktree_info ||= begin
+  # Parse git worktree list output into { name => { path:, branch: } } hash
+  def worktree_details
+    @worktree_details ||= begin
       output = `git -C #{main_repo_path} worktree list --porcelain 2>/dev/null`
-      info = {}
+      details = {}
       current_path = nil
 
       work_dir = File.join(Dir.home, 'work')
@@ -433,6 +465,12 @@ class TaskManager
           # Skip bare repo
           current_path = nil
         elsif line.start_with?('branch ') || line == 'detached'
+          branch = if line.start_with?('branch ')
+            line.sub('branch refs/heads/', '')
+          else
+            '(detached)'
+          end
+
           # Capture worktree (both named branches and detached HEAD)
           if current_path && current_path != main_repo_path
             # Use relative path from ~/work/ to support nested worktrees
@@ -442,17 +480,28 @@ class TaskManager
             else
               File.basename(current_path)
             end
-            info[name] = current_path
+            details[name] = { path: current_path, branch: branch }
           end
           current_path = nil
         end
       end
 
-      info
+      details
     end
   end
 
+  # Backward-compatible { name => path } hash
+  def worktree_info
+    @worktree_info ||= worktree_details.transform_values { |v| v[:path] }
+  end
+
+  # Get branch name for a worktree
+  def worktree_branch(tree_name)
+    worktree_details.dig(tree_name, :branch)
+  end
+
   def clear_worktree_cache
+    @worktree_details = nil
     @worktree_info = nil
   end
 

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.30"
+  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`
+
+
+
+