hiiro 0.1.149 → 0.1.151

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f67c9b0a2688514af184098d8c69497f0fe09adb4a91a4e41b17596a4069e352
-  data.tar.gz: c6f3ef4544274739bdbdde419a25101948d5af2119d0da2b6015a580864d80ec
+  metadata.gz: 98bf6f648f72277fb219044bd6f5a5e0c1320c21d122e8478cc4e6d6f7000a4b
+  data.tar.gz: 6308aa3432b0cf8e9f2fc3ca4fc66fb9075902fb3c421fad4d2dbd03f2105418
 SHA512:
-  metadata.gz: 00e92bb9a9186cea72209f320df3b43c3e3f1537596ddecd78d740d0c87ba42b7f9ccd1c250b36e6fa331371875fdf15b2f0d8baf2d7b115b76ec64183aeb9aa
-  data.tar.gz: 16e4b2d2af8857cd4d1bd7739add2d919466d58b2c0c9806371079344d8c094a66c75c32f49766efc36eda4dde6a5113c3bfde1710719919912745709d210429
+  metadata.gz: 268febf76230f6cb10ac9b492bc7c37fb34d48764b43d912dc430ae66f9b29cae1190c58109fa93d2935b4145a1e75685f6a8a1f4345e0ff53a40e70326301bc
+  data.tar.gz: dbf74be661003f9b67e878c9284d2b4a6ef4d20712226e6021023b5e2e7d8352bb671c8a86e184367fb0bad38301a4c589a6254c8d2ba2660d972a178d715feb

data/CLAUDE.md

@@ -277,13 +277,153 @@ Hiiro::Notification.show(hiiro)   # Show notification based on hiiro.args
 # Supports: -m message, -t title, -l link, -c command, -s sound
 ```
 
+### Hiiro::Queue (lib/hiiro/queue.rb)
+
+Task queue that pipes prompts to `claude` via tmux. Tasks are markdown files with optional YAML frontmatter (`task_name`, `tree_name`, `session_name`) that flow through statuses: `wip` -> `pending` -> `running` -> `done`/`failed`.
+
+Subcommands (`h queue <subcmd>`):
+- `ls`/`list` - List all tasks with status, elapsed time, and preview
+- `status` - Detailed status with working directory info
+- `add` - Create a new prompt (opens editor or accepts stdin/args, supports `-t <task>` flag)
+- `wip` - Create/edit a work-in-progress prompt
+- `ready` - Move wip task to pending
+- `run [name]` - Launch pending task(s) in tmux windows
+- `watch` - Continuously poll and launch pending tasks
+- `attach [name]` - Switch to running task's tmux window (fuzzy select if no name)
+- `kill [name]` - Kill running task's tmux window, move to failed
+- `retry [name]` - Move failed/done task back to pending
+- `clean` - Remove all done/failed task files
+- `dir` - Print queue directory path
+
+Config: `~/.config/hiiro/queue/{wip,pending,running,done,failed}/`
+
+Key internals:
+- `Queue::Prompt` - Parses frontmatter to resolve task/tree/session for working directory
+- Tasks launch in tmux windows within the task's session (from frontmatter) or default `hq` session
+- Launcher script runs `cat prompt | claude`, then moves files to done/failed based on exit code
+
+### Hiiro::ServiceManager (lib/hiiro/service_manager.rb)
+
+Manages background development services with tmux integration, env file management, and service groups.
+
+Subcommands (`h service <subcmd>`):
+- `ls`/`list` - List all services with running status, port, and base_dir
+- `start <name> [--use VAR=variation ...]` - Start a service or group; prepares env file first
+- `stop <name>` - Stop a running service (sends C-c to tmux pane or runs stop command)
+- `attach <name>` - Switch to service's tmux pane
+- `open <name>` - Open service URL in browser
+- `url <name>` / `port <name>` - Print service URL or port
+- `status <name>` - Show detailed service info (pid, pane, task, started_at)
+- `add` - Add new service via editor template
+- `rm`/`remove <name>` - Remove a service
+- `config` - Edit services.yml
+- `groups` - List all service groups and their members
+- `env <name>` - Show env_vars, their variation options, and base_env/env_file config
+
+Service config (`~/.config/hiiro/services.yml`):
+```yaml
+my-rails:
+  base_dir: apps/myapp
+  host: localhost
+  port: 3000
+  init: ["bundle install"]
+  start: bundle exec rails s -p 3000
+  stop: ""
+  cleanup: []
+  env_file: .env.development          # destination in base_dir
+  base_env: my-rails.env              # template in ~/.config/hiiro/env_templates/
+  env_vars:
+    GRAPHQL_URL:
+      variations:
+        local: http://localhost:4000/graphql
+        staging: https://graphql.staging.example.com/graphql
+```
+
+Service group config (same file, distinguished by `services:` key):
+```yaml
+my-stack:
+  services:
+    - name: my-rails
+      use:
+        GRAPHQL_URL: staging
+    - name: my-graphql
+```
+
+Key internals:
+- `prepare_env(svc_name, variation_overrides:)` - Copies base_env template from `~/.config/hiiro/env_templates/` to `base_dir/env_file`, then injects variation values
+- `find_group(name)` / `start_group(name, ...)` - Detect and start service groups, applying per-member `use:` overrides
+- Default variation is `local` when not specified
+- State tracked in `~/.config/hiiro/services/running.yml`
+
+### Hiiro::RunnerTool (lib/hiiro/runner_tool.rb)
+
+Run dev tools (linters, formatters, test suites) against changed files.
+
+Subcommands (`h run [change_set] [tool_type] [file_group]`):
+- Default (no subcmd) - Run matching tools with positional filters
+- `ls` - List configured tools with type, group, extensions, and variations
+- `add` - Add new tool via editor template
+- `rm <name>` - Remove a tool
+- `config` - Edit tools.yml
+
+Arguments (positional, any order):
+- **change_set**: `dirty` (default, git status), `branch` (diff from main), `all`
+- **tool_type**: `lint`, `test`, `format`
+- **file_type_group**: custom group identifier (e.g., `ruby`, `frontend`)
+- `--variation`/`-v <name>` - Use a named tool variation
+
+Config (`~/.config/hiiro/tools.yml`):
+```yaml
+rubocop:
+  tool_type: lint
+  command: "rubocop [FILENAMES]"
+  file_type_group: ruby
+  file_extensions: "rb"
+  variations:
+    quick: "rubocop --only Style [FILENAMES]"
+    fix: "rubocop -A [FILENAMES]"
+```
+
+`[FILENAMES]` is replaced with the space-joined list of matching files.
+
+### Hiiro::AppFiles (lib/hiiro/app_files.rb)
+
+Track frequently-used files per application, open them together in your editor.
+
+Subcommands (`h file <subcmd>`):
+- `ls [app_name]` - List tracked files (all apps or specific app)
+- `add <app> <file1> [file2 ...]` - Add files to an app's file list
+- `rm <app> <file1> [file2 ...]` - Remove files
+- `edit <app>` - Open all tracked files in editor (vim uses `-O` for vertical splits)
+
+Config: `~/.config/hiiro/app_files.yml`
+
+Files are resolved relative to the current task's tree root when an environment is available.
+
+### Jumplist (bin/h-jumplist)
+
+Vim-style navigation history for tmux. Records pane/window/session changes and lets you jump backward/forward through your navigation history.
+
+Subcommands (`h jumplist <subcmd>`):
+- `setup` - Install tmux hooks and keybindings (`Ctrl-B` back, `Ctrl-F` forward)
+- `record` - Record current position (called automatically by tmux hooks)
+- `back` - Navigate to previous position
+- `forward` - Navigate to next position
+- `ls`/`list` - Show history with timestamps and current position marker
+- `clear` - Clear history
+- `path` - Print jumplist file path
+
+Config: `~/.config/hiiro/jumplist/` (per-client entries and position files, max 50 entries)
+
+Dead panes are automatically pruned. Duplicate consecutive entries are deduplicated. Forward history is truncated when navigating to a new location (like vim).
+
 ## Key Files
 
-- `bin/h` - Entry point that loads lib/hiiro.rb
-- `bin/h-*` - External subcommands (tmux wrappers, git helpers, todo, links, etc.)
+- `exe/h` - Entry point that loads lib/hiiro.rb
+- `bin/h-*` - External subcommands (tmux wrappers, git helpers, jumplist, etc.)
 - `plugins/*.rb` - Reusable plugin modules (Pins, Project, Tasks, Notify)
 - `lib/hiiro.rb` - Main Hiiro class and Runners
-- `lib/hiiro/*.rb` - Supporting classes (Git, Matcher, Fuzzyfind, Todo, Shell, Options, Notification, Tmux)
+- `lib/hiiro/*.rb` - Supporting classes (Git, Matcher, Fuzzyfind, Todo, Shell, Options, Notification, Tmux, Queue, ServiceManager, RunnerTool, AppFiles)
 
 ## External Dependencies
 
@@ -292,6 +432,7 @@ Hiiro::Notification.show(hiiro)   # Show notification based on hiiro.args
 - `sk` (skim) or `fzf` for fuzzy finding
 - `gh` CLI for GitHub operations (h-pr)
 - `terminal-notifier` for macOS notifications (notify plugin)
+- `claude` CLI for queue task execution
 
 ## Configuration Locations
 
@@ -299,8 +440,15 @@ All config lives in `~/.config/hiiro/`:
 - `plugins/` - Auto-loaded plugin files
 - `pins/` - Per-command YAML key-value storage
 - `tasks/` - Task metadata for worktree management
+- `queue/` - Prompt queue (wip, pending, running, done, failed)
+- `services/` - Service runtime state
+- `jumplist/` - Per-client tmux navigation history
+- `env_templates/` - Base .env template files for services
 - `projects.yml` - Project directory aliases
 - `apps.yml` - App directory mappings for task plugin
+- `services.yml` - Service and service group definitions
+- `tools.yml` - Runner tool definitions
+- `app_files.yml` - Per-app tracked file lists
 
 
 # Groups of files

data/README.md

@@ -83,6 +83,10 @@ h ping
 | `h pr` | GitHub PR management via gh CLI |
 | `h project` | Project navigation with tmux session management |
 | `h queue` | Claude prompt queue with tmux-based task execution |
+| `h jumplist` | Vim-style tmux navigation history (back/forward through panes) |
+| `h service` | Manage background dev services with env variations and groups |
+| `h file` | Track and open frequently-used files per app |
+| `h run` | Run dev tools (lint/test/format) against changed files |
 | `h session` | Tmux session management |
 | `h sha` | Extract short SHA from git log |
 | `h todo` | Todo list management with tags and task association |
@@ -214,9 +218,15 @@ All configuration lives in `~/.config/hiiro/`:
   plugins/        # Plugin files (auto-loaded)
   pins/           # Pin storage (per command)
   queue/          # Prompt queue (wip, pending, running, done, failed)
+  services/       # Service runtime state
+  jumplist/       # Per-client tmux navigation history
+  env_templates/  # Base .env templates for services
   tasks/          # Task metadata
   projects.yml    # Project aliases
   apps.yml        # App directory mappings
+  services.yml    # Service and service group definitions
+  tools.yml       # Runner tool definitions
+  app_files.yml   # Per-app tracked file lists
   todo.yml        # Todo items
 ```
 

data/lib/hiiro/service_manager.rb

@@ -1,6 +1,7 @@
 require 'yaml'
 require 'fileutils'
 require 'time'
+require 'ostruct'
 
 class Hiiro
   class ServiceManager
@@ -108,13 +109,50 @@ class Hiiro
         return false
       end
 
+      session = tmux_info[:session] || current_tmux_session
+      unless session
+        puts "tmux is required to start a service group"
+        return false
+      end
+
       puts "Starting group '#{group[:name]}'..."
-      members.each do |member|
+
+      # Create one window for the group, split panes for each service
+      first_member = members.first
+      first_name = first_member['name'] || first_member[:name]
+      first_svc = find_service(first_name)
+      first_base_dir = first_svc&.[](:base_dir) || Dir.pwd
+
+      # Create a new window for the group
+      window_target = create_tmux_window(session, group[:name], first_base_dir)
+      first_pane_id = capture_pane_id(window_target)
+
+      members.each_with_index do |member, idx|
         member_name = member['name'] || member[:name]
         use_overrides = member['use'] || member[:use] || {}
 
         prepare_env(member_name, variation_overrides: use_overrides)
-        start(member_name, tmux_info: tmux_info, task_info: task_info, skip_env: true)
+
+        svc = find_service(member_name)
+        next unless svc
+
+        base_dir = svc[:base_dir] || Dir.pwd
+
+        if idx == 0
+          # First service uses the initial pane
+          pane_id = first_pane_id
+        else
+          # Subsequent services get split panes
+          pane_id = split_tmux_pane(window_target, base_dir)
+        end
+
+        member_tmux_info = tmux_info.merge(
+          session: session,
+          window: window_target,
+          pane: pane_id,
+        )
+
+        start(member_name, tmux_info: member_tmux_info, task_info: task_info, skip_env: true, skip_window_creation: true)
       end
       true
     end
@@ -128,7 +166,7 @@ class Hiiro
       load_state
     end
 
-    def start(name, tmux_info: {}, task_info: {}, variation_overrides: {}, skip_env: false)
+    def start(name, tmux_info: {}, task_info: {}, variation_overrides: {}, skip_env: false, skip_window_creation: false)
       svc = find_service(name)
       unless svc
         puts "Service '#{name}' not found"
@@ -167,20 +205,35 @@ class Hiiro
         return false
       end
 
+      # Coerce start command to array
+      start_cmds = Array(start_cmd)
+
       base_dir = svc[:base_dir]
-      pane_id = tmux_info[:pane] || ENV['TMUX_PANE']
+      session = tmux_info[:session] || current_tmux_session
+
+      if session && !skip_window_creation
+        # Create a new tmux window for this service
+        window_target = create_tmux_window(session, svc_name, base_dir || Dir.pwd)
+        pane_id = capture_pane_id(window_target)
+      elsif session && skip_window_creation
+        # Pane already created by start_group
+        pane_id = tmux_info[:pane]
+        window_target = tmux_info[:window]
+      else
+        pane_id = nil
+        window_target = nil
+      end
 
       if pane_id
-        if base_dir
-          system('tmux', 'send-keys', '-t', pane_id, "cd #{base_dir} && #{start_cmd}", 'Enter')
-        else
-          system('tmux', 'send-keys', '-t', pane_id, start_cmd, 'Enter')
-        end
+        # Send each start command to the pane
+        combined_cmd = start_cmds.join(' && ')
+        system('tmux', 'send-keys', '-t', pane_id, combined_cmd, 'Enter')
       else
+        combined_cmd = start_cmds.join(' && ')
         if base_dir
-          system("cd #{base_dir} && #{start_cmd} &")
+          system("cd #{base_dir} && #{combined_cmd} &")
         else
-          system("#{start_cmd} &")
+          system("#{combined_cmd} &")
         end
       end
 
@@ -188,8 +241,8 @@ class Hiiro
       state = load_state
       state[svc_name] = {
         'pid' => nil,
-        'tmux_session' => tmux_info[:session],
-        'tmux_window' => tmux_info[:window],
+        'tmux_session' => session || tmux_info[:session],
+        'tmux_window' => window_target || tmux_info[:window],
         'tmux_pane' => pane_id,
         'task' => task_info[:task_name],
         'tree' => task_info[:tree],
@@ -219,7 +272,7 @@ class Hiiro
       info = running_services[svc_name]
       pane_id = info['tmux_pane']
 
-      if svc[:stop]
+      if svc[:stop] && !svc[:stop].to_s.strip.empty?
         stop_cmd = svc[:stop]
         if info['pid']
           stop_cmd = stop_cmd.gsub('$PID', info['pid'].to_s)
@@ -259,11 +312,16 @@ class Hiiro
       info = running_services[svc_name]
       pane_id = info['tmux_pane']
       session = info['tmux_session']
+      window = info['tmux_window']
 
       if session
         system('tmux', 'switch-client', '-t', session)
       end
 
+      if window
+        system('tmux', 'select-window', '-t', window)
+      end
+
       if pane_id
         system('tmux', 'select-pane', '-t', pane_id)
       end
@@ -397,8 +455,6 @@ class Hiiro
 
           tmux_info = {
             session: ENV['TMUX'] ? `tmux display-message -p '#S'`.chomp : nil,
-            window: ENV['TMUX'] ? `tmux display-message -p '#I'`.chomp : nil,
-            pane: ENV['TMUX_PANE'],
           }
 
           task_info = {}
@@ -498,8 +554,7 @@ class Hiiro
             'host' => 'localhost',
             'port' => '',
             'init' => [],
-            'start' => '',
-            'stop' => '',
+            'start' => [''],
             'cleanup' => [],
           }
 
@@ -605,6 +660,26 @@ class Hiiro
 
     private
 
+    def current_tmux_session
+      return nil unless ENV['TMUX']
+      `tmux display-message -p '#S'`.chomp
+    end
+
+    def create_tmux_window(session, name, start_dir)
+      system('tmux', 'new-window', '-d', '-t', session, '-n', name, '-c', start_dir)
+      "#{session}:#{name}"
+    end
+
+    def capture_pane_id(window_target)
+      `tmux list-panes -t #{window_target} -F '\#{pane_id}'`.chomp.split("\n").last
+    end
+
+    def split_tmux_pane(window_target, start_dir)
+      system('tmux', 'split-window', '-d', '-t', window_target, '-c', start_dir)
+      system('tmux', 'select-layout', '-t', window_target, 'even-vertical')
+      `tmux list-panes -t #{window_target} -F '\#{pane_id}'`.chomp.split("\n").last
+    end
+
     def load_config
       return {} unless File.exist?(config_file)
       YAML.safe_load_file(config_file, permitted_classes: [Symbol]) || {}

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.149"
+  VERSION = "0.1.151"
 end

data/lib/hiiro.rb

@@ -2,6 +2,7 @@ require "fileutils"
 require "yaml"
 require "shellwords"
 require "pry"
+require "ostruct"
 
 require_relative "hiiro/version"
 require_relative "hiiro/bins"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.149
+  version: 0.1.151
 platform: ruby
 authors:
 - Joshua Toyota