hiiro 0.1.104 → 0.1.105.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91b42e1f81626b60d53e555716eb8dd2f5ed78430150d5f459f057c1866c1fc5
-  data.tar.gz: 752c39ce5b291f32e23b5ad542f7b92659f65e3ace6290dbd014609113bca83e
+  metadata.gz: 02a9dfd205fe167b06ddca8e9166eef9fb0455e579e0f30aea8ebf2beebced8a
+  data.tar.gz: f6a2b07f167e9d9ce5e1e57b008b2860cb7888dbb56d4f8602a0150a3aae243c
 SHA512:
-  metadata.gz: 6d33442eb08708cd8a77e29c8e8534925951703ee158f81109d0137004d25facaa5640d2381679885f1e9cc1a9d78efba927af1fae7e71f742826adfc342c029
-  data.tar.gz: 6d8f6df9a92a723ebeee3c0bdb77b9d8260d538012e84aa391ac5aacf0b6ebe9f81770a159449bdaa39b20ebabe4326bee083e4eb6171d6c656ccc6e1cc0c992
+  metadata.gz: 8575faa796545313d705f3c850d94b922b6987b063ce8a645942a8ec94f19039719800f80cb360a1e2436cc4dc506f92f519eb73f7d70b1b9890593bf83f7270
+  data.tar.gz: 827a12ffa83d83c837d46daf38d0be7ec46f2b5f92d6d6ab5fea62e45e9b6f9d854347bf516ddef2e98f2414c3706158693e4939895f607d753ea39c9c1e174a

data/bin/h-app

@@ -43,7 +43,7 @@ def send_cd(path)
   end
 end
 
-Hiiro.run(*ARGV, plugins: [:Tasks]) {
+Hiiro.run(*ARGV) {
   add_subcmd(:config) {
     editor = ENV['EDITOR'] || 'nvim'
     system(editor, APPS_FILE)

data/bin/h-branch

@@ -116,7 +116,7 @@ class BranchManager
   end
 end
 
-Hiiro.run(*ARGV, plugins: [Tasks]) do
+Hiiro.run(*ARGV) do
   manager = BranchManager.new(self)
 
   add_subcmd(:edit) { system(ENV['EDITOR'] || 'nvim', __FILE__) }

data/bin/h-pr

@@ -416,7 +416,7 @@ class PinnedPRManager
   end
 end
 
-Hiiro.run(*ARGV, plugins: [Tasks, Tmux, Pins]) do
+Hiiro.run(*ARGV, plugins: [Pins]) do
   manager = PRManager.new(self)
   pinned_manager = PinnedPRManager.new
 

data/bin/h-queue

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'hiiro'
+require_relative '../lib/hiiro/queue'
+
+q = Hiiro::Queue.current
+Hiiro::Queue.build_hiiro(
+  Hiiro.new('h-queue', *ARGV),
+  q
+).run

data/bin/h-session

@@ -4,7 +4,7 @@ require 'hiiro'
 require 'tempfile'
 require 'yaml'
 
-Hiiro.run(*ARGV, plugins: [Pins, Tasks]) do
+Hiiro.run(*ARGV, plugins: [Pins]) do
   tmux = tmux_client
 
   add_subcmd(:ls, :list) { |*args|

data/hiiro.gemspec

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

data/lib/hiiro/queue.rb

@@ -0,0 +1,418 @@
+require 'yaml'
+require 'fileutils'
+require 'shellwords'
+require 'time'
+require 'front_matter_parser'
+
+class Hiiro
+  class Queue
+    DIR = File.join(Dir.home, '.config/hiiro/queue')
+    TMUX_SESSION = 'hq'
+    STATUSES = %w[wip pending running done failed].freeze
+
+    def self.current(hiiro=nil)
+      @current ||= new(hiiro)
+    end
+
+    attr_reader :hiiro
+
+    def initialize(hiiro=nil)
+      @hiiro = hiiro
+    end
+
+    def read_prompt(filepath)
+      return false unless File.exist?(filepath)
+
+      Prompt.from_file(filepath)
+    end
+
+    def queue_dirs
+      @queue_dirs ||= STATUSES.each_with_object({}) do |name, h|
+        dir = File.join(DIR, name)
+        FileUtils.mkdir_p(dir)
+        h[name.to_sym] = dir
+      end
+    end
+
+    def tasks_in(status)
+      dir = queue_dirs[status]
+      Dir.glob(File.join(dir, '*.md')).sort.map { |f| File.basename(f, '.md') }
+    end
+
+    def all_tasks
+      STATUSES.flat_map do |status|
+        tasks_in(status.to_sym).map { |name| { name: name, status: status } }
+      end
+    end
+
+    def meta_for(name, status)
+      path = File.join(queue_dirs[status], "#{name}.meta")
+      File.exist?(path) ? YAML.safe_load_file(path) : nil
+    end
+
+    def find_task(name)
+      STATUSES.each do |status|
+        md = File.join(queue_dirs[status.to_sym], "#{name}.md")
+        return { name: name, status: status } if File.exist?(md)
+      end
+      nil
+    end
+
+    def ensure_tmux_session
+      unless system('tmux', 'has-session', '-t', TMUX_SESSION, out: File::NULL, err: File::NULL)
+        system('tmux', 'new-session', '-d', '-s', TMUX_SESSION)
+      end
+    end
+
+    def launch_task(name)
+      dirs = queue_dirs
+      md_file = File.join(dirs[:pending], "#{name}.md")
+      return unless File.exist?(md_file)
+
+      running_md = File.join(dirs[:running], "#{name}.md")
+      FileUtils.mv(md_file, running_md)
+
+      prompt_obj = Prompt.from_file(running_md, hiiro: hiiro)
+      prompt_text = File.read(running_md).strip
+
+      # Determine target tmux session and working directory from frontmatter
+      target_session = TMUX_SESSION
+      working_dir = Dir.pwd
+
+      if prompt_obj
+        if prompt_obj.task
+          target_session = prompt_obj.task.session_name
+          tree = prompt_obj.task.tree
+          working_dir = tree.path if tree
+        elsif prompt_obj.session
+          target_session = prompt_obj.session.name
+        end
+
+        if prompt_obj.tree
+          working_dir = prompt_obj.tree.path
+        end
+      end
+
+      # Ensure the target session exists
+      unless system('tmux', 'has-session', '-t', target_session, out: File::NULL, err: File::NULL)
+        system('tmux', 'new-session', '-d', '-s', target_session, '-c', working_dir)
+      end
+
+      # Build the cleanup script that runs after claude exits
+      cleanup_ruby = [
+        'ruby', '-e',
+        'require "fileutils"; ' \
+        "name=#{name.inspect}; qdir=#{DIR.inspect}; " \
+        'exit_code = ENV["HQ_EXIT"].to_i; ' \
+        'src=File.join(qdir,"running",name+".md"); ' \
+        'dst_dir = exit_code == 0 ? "done" : "failed"; ' \
+        'FileUtils.mv(src, File.join(qdir, dst_dir, name+".md")) if File.exist?(src); ' \
+        'meta=File.join(qdir,"running",name+".meta"); ' \
+        'FileUtils.mv(meta, File.join(qdir, dst_dir, name+".meta")) if File.exist?(meta)'
+      ].shelljoin
+
+      # Run claude interactively in tmux window, then cleanup on exit
+      shell_cmd = "cd #{Shellwords.shellescape(working_dir)} && claude #{Shellwords.shellescape(prompt_text)}; HQ_EXIT=$?; #{cleanup_ruby}; exec #{ENV['SHELL'] || 'zsh'}"
+
+      system('tmux', 'new-window', '-t', target_session, '-n', name, '-c', working_dir, shell_cmd)
+
+      # Write meta sidecar
+      meta = {
+        'tmux_session' => target_session,
+        'tmux_window' => name,
+        'started_at' => Time.now.iso8601,
+        'working_dir' => working_dir,
+      }
+      if prompt_obj
+        meta['task_name'] = prompt_obj.task_name if prompt_obj.task_name
+        meta['tree_name'] = prompt_obj.tree_name if prompt_obj.tree_name
+        meta['session_name'] = prompt_obj.session_name if prompt_obj.session_name
+      end
+      File.write(File.join(dirs[:running], "#{name}.meta"), meta.to_yaml)
+
+      puts "Launched: #{name} [#{target_session}]"
+    end
+
+    def slugify(text)
+      text.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-|-$/, '')[0, 60]
+    end
+
+    def add_with_frontmatter(content, task_info: nil)
+      queue_dirs # ensure dirs exist
+
+      if task_info
+        fm = {}
+        fm['task_name'] = task_info[:task_name] if task_info[:task_name]
+        fm['tree_name'] = task_info[:tree_name] if task_info[:tree_name]
+        fm['session_name'] = task_info[:session_name] if task_info[:session_name]
+
+        if fm.any?
+          content = "---\n#{fm.map { |k, v| "#{k}: #{v}" }.join("\n")}\n---\n#{content}"
+        end
+      end
+
+      name = slugify(content.lines.reject { |l| l.start_with?('---') || l.match?(/^\w+:/) }.first.to_s.strip)
+      return nil if name.empty?
+
+      base_name = name
+      counter = 1
+      while File.exist?(File.join(DIR, 'pending', "#{name}.md"))
+        counter += 1
+        name = "#{base_name}-#{counter}"
+      end
+
+      path = File.join(DIR, 'pending', "#{name}.md")
+      File.write(path, content + "\n")
+      { name: name, path: path }
+    end
+
+    def self.build_hiiro(parent_hiiro, q=nil, task_info: nil)
+      q ||= current(parent_hiiro)
+
+      parent_hiiro.make_child do |h|
+        h.add_subcmd(:watch) {
+          q.queue_dirs
+          puts "Watching #{File.join(DIR, 'pending')} ..."
+          puts "Press Ctrl-C to stop"
+          loop do
+            q.tasks_in(:pending).each { |name| q.launch_task(name) }
+            sleep 2
+          end
+        }
+
+        h.add_subcmd(:run) { |name = nil|
+          if name
+            name = name.sub(/\.md$/, '')
+            found = q.find_task(name)
+            if found.nil?
+              puts "Task not found: #{name}"
+              next
+            end
+            if found[:status] != 'pending'
+              puts "Task '#{name}' is #{found[:status]}, not pending"
+              next
+            end
+            q.launch_task(name)
+          else
+            pending = q.tasks_in(:pending)
+            if pending.empty?
+              puts "No pending tasks"
+              next
+            end
+            pending.each { |n| q.launch_task(n) }
+          end
+        }
+
+        h.add_subcmd(:ls) {
+          tasks = q.all_tasks
+          if tasks.empty?
+            puts "No tasks"
+            next
+          end
+          tasks.each do |t|
+            puts "%-10s %s" % [t[:status], t[:name]]
+          end
+        }
+
+        h.add_subcmd(:list) {
+          tasks = q.all_tasks
+          if tasks.empty?
+            puts "No tasks"
+            next
+          end
+          tasks.each do |t|
+            puts "%-10s %s" % [t[:status], t[:name]]
+          end
+        }
+
+        h.add_subcmd(:status) {
+          tasks = q.all_tasks
+          if tasks.empty?
+            puts "No tasks"
+            next
+          end
+          tasks.each do |t|
+            meta = q.meta_for(t[:name], t[:status].to_sym)
+            line = "%-10s %s" % [t[:status], t[:name]]
+            if meta
+              started = meta['started_at']
+              if started && t[:status] == 'running'
+                elapsed = Time.now - Time.parse(started)
+                mins = (elapsed / 60).to_i
+                line += "  (#{mins}m elapsed)"
+              end
+              line += "  [#{meta['tmux_session']}:#{meta['tmux_window']}]" if meta['tmux_session']
+              line += "  dir:#{meta['working_dir']}" if meta['working_dir']
+            end
+            puts line
+          end
+        }
+
+        h.add_subcmd(:attach) { |name = nil|
+          running = q.tasks_in(:running)
+          if running.empty?
+            puts "No running tasks"
+            next
+          end
+
+          if name.nil?
+            name = running.size == 1 ? running.first : h.fuzzyfind(running)
+          end
+
+          if name
+            meta = q.meta_for(name, :running)
+            session = meta&.[]('tmux_session') || TMUX_SESSION
+            exec('tmux', 'select-window', '-t', "#{session}:#{name}")
+          end
+        }
+
+        h.add_subcmd(:add) { |*args|
+          q.queue_dirs
+
+          if args.empty? && !$stdin.tty?
+            content = $stdin.read.strip
+          elsif args.any?
+            content = args.join(' ')
+          else
+            require 'tempfile'
+            tmpfile = Tempfile.new(['hq-', '.md'])
+
+            # Pre-fill with frontmatter template if task_info is available
+            if task_info
+              fm_lines = ["---"]
+              fm_lines << "task_name: #{task_info[:task_name]}" if task_info[:task_name]
+              fm_lines << "tree_name: #{task_info[:tree_name]}" if task_info[:tree_name]
+              fm_lines << "session_name: #{task_info[:session_name]}" if task_info[:session_name]
+              fm_lines << "---"
+              fm_lines << ""
+              tmpfile.write(fm_lines.join("\n"))
+            end
+
+            tmpfile.close
+            editor = ENV['EDITOR'] || 'vim'
+            system(editor, tmpfile.path)
+            content = File.read(tmpfile.path).strip
+            tmpfile.unlink
+            if content.empty?
+              puts "Aborted (empty file)"
+              next
+            end
+          end
+
+          result = q.add_with_frontmatter(content, task_info: task_info)
+          if result
+            puts "Created: #{result[:path]}"
+          else
+            puts "Could not generate a task name"
+          end
+        }
+
+        h.add_subcmd(:kill) { |name = nil|
+          running = q.tasks_in(:running)
+          if running.empty?
+            puts "No running tasks"
+            next
+          end
+
+          if name.nil?
+            name = running.size == 1 ? running.first : h.fuzzyfind(running)
+          end
+
+          next unless name
+
+          meta = q.meta_for(name, :running)
+          session = meta&.[]('tmux_session') || TMUX_SESSION
+          system('tmux', 'kill-window', '-t', "#{session}:#{name}")
+
+          dirs = q.queue_dirs
+          md = File.join(dirs[:running], "#{name}.md")
+          meta_path = File.join(dirs[:running], "#{name}.meta")
+          FileUtils.mv(md, File.join(dirs[:failed], "#{name}.md")) if File.exist?(md)
+          FileUtils.mv(meta_path, File.join(dirs[:failed], "#{name}.meta")) if File.exist?(meta_path)
+          puts "Killed: #{name}"
+        }
+
+        h.add_subcmd(:retry) { |name = nil|
+          retryable = q.tasks_in(:failed) + q.tasks_in(:done)
+          if retryable.empty?
+            puts "No failed/done tasks to retry"
+            next
+          end
+
+          if name.nil?
+            name = retryable.size == 1 ? retryable.first : h.fuzzyfind(retryable)
+          end
+
+          next unless name
+
+          found = q.find_task(name)
+          unless found && %w[failed done].include?(found[:status])
+            puts "Task '#{name}' is not in failed/done state"
+            next
+          end
+
+          dirs = q.queue_dirs
+          src_dir = dirs[found[:status].to_sym]
+          FileUtils.mv(File.join(src_dir, "#{name}.md"), File.join(dirs[:pending], "#{name}.md"))
+          meta_path = File.join(src_dir, "#{name}.meta")
+          FileUtils.rm_f(meta_path) if File.exist?(meta_path)
+          puts "Moved to pending: #{name}"
+        }
+
+        h.add_subcmd(:clean) {
+          dirs = q.queue_dirs
+          count = 0
+          %i[done failed].each do |status|
+            Dir.glob(File.join(dirs[status], '*')).each do |f|
+              FileUtils.rm_f(f)
+              count += 1
+            end
+          end
+          puts "Cleaned #{count} files"
+        }
+
+        h.add_subcmd(:dir) {
+          q.queue_dirs
+          puts DIR
+        }
+      end
+    end
+
+    class Prompt
+      def self.from_file(path, hiiro: nil)
+        return unless File.exist?(path)
+
+        new(FrontMatterParser::Parser.parse_file(path), hiiro:)
+      end
+
+      attr_reader :hiiro, :doc, :frontmatter, :prompt
+      attr_reader :task_name, :tree_name, :session_name
+
+      def initialize(doc, hiiro: nil)
+        @hiiro = hiiro
+        @doc = doc
+        @frontmatter = doc.front_matter
+        @prompt = prompt
+
+        @task_name = doc.front_matter['task_name']
+        @tree_name = doc.front_matter['tree_name']
+        @session_name = doc.front_matter['session_name']
+      end
+
+      def task
+        return nil unless task_name
+        hiiro&.environment&.find_task(task_name)
+      end
+
+      def session
+        return nil unless session_name
+        hiiro&.environment&.find_session(session_name)
+      end
+
+      def tree
+        return nil unless tree_name
+        hiiro&.environment&.find_tree(tree_name)
+      end
+    end
+  end
+end