hiiro 0.1.31 → 0.1.33.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9acf06495590129ec1870e030280f89addc30177e768c360aa8e6891d69ece7
-  data.tar.gz: afdc44652ae0ea1efbc107f8bd4b972c88477f07cf247665a66104859f49a0c2
+  metadata.gz: b2e1bf3310b631a31f3eddd49217193c44f9b7a080ca200db1524e3dbb80f8c3
+  data.tar.gz: efcf8d31f760fafde059592b53469189c7b21ac3a6650334e381fbf7a9a6c97a
 SHA512:
-  metadata.gz: 74d7b72bcb20c9cfdde0ef7c63d02d270f6f95fd05510fb5ff25f0543c4830f15418718f693fce532c8388f9c9a80851a9d13969646d75b187119f08d3d9cd64
-  data.tar.gz: 5f00c18b9bf9c47f8063a37dd6984bcbf97d7bdc4d06f06d918e1aa93aa48c316a14fd76301c56e029eafab2acacbc163f3e50c040b6d85f64217611554a56ae
+  metadata.gz: 4056150e8f6605fe2568e39e84413581edb31170bd7a93ceb8891513c94305d6a3c30bab948adbba193ae599dee6d43fe04dbeb83f3d0009795b60bb12009fa0
+  data.tar.gz: a8b364f3931e8597c254a1fdcd9f59442f6e9c74912985396dd2466289e43a1663edb9b92336c57115681a1a36a78ff68cc98e48ad34586db7feff1454d3a987

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

@@ -6,8 +6,7 @@ require "fileutils"
 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

@@ -4,8 +4,7 @@ require "hiiro"
 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-buffer

@@ -12,7 +12,7 @@ def find_buffer(partial)
   buffer
 end
 
-o = Hiiro.init(*ARGV, plugins: [Pins])
+o = Hiiro.init(*ARGV, plugins: [:Pins])
 
 o.add_subcmd(:ls) { |*args|
   system('tmux', 'list-buffers', *args)

data/bin/h-link

@@ -193,7 +193,7 @@ class LinkManager
 end
 
 lm = LinkManager.new
-o = Hiiro.init(*ARGV, plugins: [Tmux, Pins], links_file: lm.links_file)
+o = Hiiro.init(*ARGV, plugins: [:Tmux, :Pins], links_file: lm.links_file)
 
 o.add_subcmd(:add) do |*args|
   links = lm.load_links

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

@@ -7,8 +7,7 @@ require "fileutils"
 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-task → h-otask}

@@ -5,7 +5,7 @@ require "fileutils"
 require "yaml"
 require "pathname"
 
-hiiro = Hiiro.init(*ARGV, plugins: [Tmux])
+hiiro = Hiiro.init(*ARGV, plugins: [:Tmux])
 
 class TaskManager
   attr_reader :hiiro

data/bin/h-pane

@@ -2,7 +2,7 @@
 
 load File.join(Dir.home, 'bin', 'h')
 
-o = Hiiro.init(*ARGV, plugins: [Pins])
+o = Hiiro.init(*ARGV, plugins: [:Pins])
 
 o.add_subcmd(:ls) { |*args|
   system('tmux', 'list-panes', *args)

data/bin/h-plugin

@@ -5,7 +5,7 @@ require 'json'
 require 'hiiro'
 
 BASE_DIR = File.join(Dir.home, '.config/hiiro/plugins')
-o = Hiiro.init(*ARGV, plugins: [Tmux, Pins], dir: BASE_DIR)
+o = Hiiro.init(*ARGV, plugins: [:Tmux, :Pins], dir: BASE_DIR)
 
 def plugin_files
   Dir.glob(File.join(BASE_DIR, '**/*'))

data/bin/h-pr

@@ -6,8 +6,7 @@ require "fileutils"
 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-session

@@ -22,7 +22,7 @@ require 'rspec'
 #    has       (subcommand)  /Users/unixsuperhero/bin/h-session:139
 #    info      (subcommand)  /Users/unixsuperhero/bin/h-session:143
 
-o = Hiiro.init(*ARGV, plugins: [Pins])
+o = Hiiro.init(*ARGV, plugins: [:Pins])
 
 o.add_subcmd(:ls) { |*args|
   system('tmux', 'list-sessions', *args)

data/bin/h-sha

@@ -4,7 +4,7 @@ require 'hiiro'
 
 BASE_DIR = File.join(Dir.home, 'work/carrot')
 
-Hiiro.init(*ARGV, plugins: [Tmux, Pins, Project]) { |hiiro|
+Hiiro.init(*ARGV, plugins: [:Tmux, :Pins, :Project]) { |hiiro|
 
 }.run
 

data/bin/h-vim

@@ -5,7 +5,7 @@ require 'hiiro'
 BASE_DIR = CONFIG_DIR = File.join(Dir.home, '.config/nvim')
 TMUX_SESSION_NAME = 'vim'
 
-o = Hiiro.init(*ARGV, plugins: [Tmux, Pins, Project])
+o = Hiiro.init(*ARGV, plugins: [:Tmux, :Pins, :Project])
 
 o.add_subcmd(:edit) { |*args|
   nvim = ENV['EDITOR']

data/bin/h-window

@@ -2,7 +2,7 @@
 
 load File.join(Dir.home, 'bin', 'h')
 
-o = Hiiro.init(*ARGV, plugins: [Pins])
+o = Hiiro.init(*ARGV, plugins: [:Pins])
 
 o.add_subcmd(:ls) { |*args|
   system('tmux', 'list-windows', *args)

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/plugins.rb

@@ -0,0 +1,64 @@
+class Hiiro
+  class Plugins
+    class << self
+      def load_plugin(name)
+        name_str = name.to_s
+        return const_get(name_str) if plugin_loaded?(name_str)
+
+        path = plugin_path(name_str)
+        unless path
+          warn "[hiiro] plugin not found: #{name_str}"
+          return nil
+        end
+
+        module_eval(File.read(path), path, 1)
+
+        unless const_defined?(name_str, false)
+          warn "[hiiro] plugin #{name_str} did not define expected constant"
+          return nil
+        end
+
+        @loaded_plugins ||= []
+        @loaded_plugins << name_str
+        const_get(name_str)
+      end
+
+      def plugin_loaded?(name_str)
+        (@loaded_plugins || []).include?(name_str.to_s)
+      end
+
+      def plugin_path(name_str)
+        plugin_filename = name_str.underscore + '.rb'
+
+        paths_to_check = [
+          File.join(Dir.home, '.config/hiiro/plugins'),
+          File.join(File.expand_path('../..', __FILE__), 'plugins'),
+        ]
+
+        paths_to_check.each do |dir|
+          full_path = File.join(dir, plugin_filename)
+          return full_path if File.exist?(full_path)
+        end
+
+        nil
+      end
+
+      def load_all
+        user_dir = File.join(Dir.home, '.config/hiiro/plugins')
+        gem_dir = File.join(File.expand_path('../..', __FILE__), 'plugins')
+
+        FileUtils.mkdir_p(user_dir) unless Dir.exist?(user_dir)
+
+        user_files = Dir.glob(File.join(user_dir, '*.rb'))
+        user_basenames = user_files.map { |f| File.basename(f) }
+
+        gem_files = Dir.exist?(gem_dir) ? Dir.glob(File.join(gem_dir, '*.rb')) : []
+        fallback_files = gem_files.reject { |f| user_basenames.include?(File.basename(f)) }
+
+        (user_files + fallback_files).each do |path|
+          module_eval(File.read(path), path, 1)
+        end
+      end
+    end
+  end
+end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.31"
+  VERSION = "0.1.33.pre.1"
 end

data/lib/hiiro.rb

@@ -4,15 +4,29 @@ require "shellwords"
 
 require_relative "hiiro/version"
 require_relative "hiiro/history"
+require_relative "hiiro/plugins"
+
+class String
+  def underscore(camel_cased_word=self)
+    regex = /(?:(?<=([A-Za-z\d]))|\b)((?-mix:(?=a)b))(?=\b|[^a-z])/
+    return camel_cased_word.to_s.dup unless /[A-Z-]|::/.match?(camel_cased_word)
+    word = camel_cased_word.to_s.gsub("::", "/")
+    word.gsub!(regex) { "#{$1 && '_' }#{$2.downcase}" }
+    word.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end
 
 class Hiiro
   def self.init(*args, plugins: [], logging: false, **values, &block)
-    load_env
+    load_plugins(plugins)
     args = ARGV if args.empty?
 
     new($0, *args, logging: logging, **values).tap do |hiiro|
       History.load(hiiro)
-      hiiro.load_plugins(*plugins)
+      hiiro.init_plugins(*plugins)
 
       hiiro.add_subcmd(:edit, **values) { |*args|
         system(ENV['EDITOR'] || 'nvim', hiiro.bin)
@@ -28,12 +42,10 @@ class Hiiro
     hiiro.run
   end
 
-  def self.load_env
-    Config.plugin_files.each do |plugin_file|
-      require plugin_file
+  def self.load_plugins(plugin_list)
+    plugin_list.each do |name|
+      Plugins.load_plugin(name.to_s)
     end
-
-    self
   end
 
   attr_reader :bin, :bin_name, :all_args, :full_command
@@ -119,11 +131,24 @@ class Hiiro
 
   def pins = @pins ||= Pin.new(self)
 
+  def init_plugins(*names)
+    names.flatten.each do |name|
+      plugin_const = Hiiro::Plugins.const_get(name.to_s) rescue nil
+      next unless plugin_const
+      load_plugin(plugin_const)
+    end
+  end
+
   def load_plugins(*plugins)
     plugins.flatten.each { |plugin| load_plugin(plugin) }
   end
 
-  def load_plugin(plugin_const)
+  def load_plugin(plugin)
+    plugin_const = case plugin
+      when Module then plugin
+      when String, Symbol then Hiiro::Plugins.load_plugin(plugin.to_s)
+      end
+    return unless plugin_const
     return if @loaded_plugins.include?(plugin_const)
 
     plugin_const.load(self)
@@ -180,14 +205,6 @@ class Hiiro
 
   class Config
     class << self
-      def plugin_files
-        Dir.glob(File.join(plugin_dir, '*'))
-      end
-
-      def plugin_dir
-        config_dir('plugins')
-      end
-
       def config_dir(subdir=nil)
         File.join(Dir.home, '.config/hiiro', *[subdir].compact).tap do |config_path|
           FileUtils.mkdir_p(config_path) unless Dir.exist?(config_path)
@@ -437,6 +454,4 @@ class Hiiro
       end
     end
   end
-
-  load_env
 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