Module: Hiiro::Tasks

Defined in:

lib/hiiro/tasks.rb

Class Method Summary

• .build_hiiro(parent_hiiro, tm) ⇒ Object

Class Method Details

.build_hiiro(parent_hiiro, tm) ⇒ Object

# File 'lib/hiiro/tasks.rb', line 799

def self.build_hiiro(parent_hiiro, tm)
  task_hiiro = parent_hiiro.make_child do |h|

    # Shared task resolver: given parsed opts and remaining positional args,
    # returns [task, remaining_positional]. First positional arg is treated as
    # a task name (prefix-matched) if no -f/-t flag is given; falls back to
    # current task if no match.
    resolve_task = lambda do |opts, positional|
      if opts.find
        sel = tm.select_task_interactive
        next [nil, positional] unless sel
        task = sel.is_a?(Hiiro::Task) ? sel : nil
        [task, positional]
      elsif opts.task
        [tm.resolve_name(opts.task), positional]
      elsif positional.any?
        found = tm.resolve_name(positional.first)
        found ? [found, positional[1..]] : [tm.current_task, positional]
      else
        [tm.current_task, positional]
      end
    end

    task_opts_block = proc {
      option(:task, short: :t, desc: 'Task name')
      flag(:find,   short: :f, desc: 'Choose task interactively')
      flag(:all,    short: :a, desc: 'Operate on all tasks (positional args = prefix filters)')
    }

    h.add_subcmd(:list) do |*args|
      opts = Hiiro::Options.parse(args) { option(:tag, short: 't', desc: 'filter by tag (OR when multiple)', multi: true) }
      tm.list(tags_filter: Array(opts.tag).reject(&:empty?))
    end
    h.add_subcmd(:ls) do |*args|
      opts = Hiiro::Options.parse(args) { option(:tag, short: 't', desc: 'filter by tag (OR when multiple)', multi: true) }
      tm.list(tags_filter: Array(opts.tag).reject(&:empty?))
    end

    h.add_subcmd(:tag) do |*raw_args|
      tag_store = Hiiro::Tags.new(:task)
      opts      = Hiiro::Options.parse(raw_args) { flag(:edit, short: 'e', desc: 'open YAML editor to bulk-tag tasks') }

      if opts.edit
        task_names = tm.tasks.map(&:name)
        task_lines = task_names.map { |n| "- #{n}" }
        yaml_content = "# Select tasks to tag.\n\ntasks:\n#{task_lines.join("\n")}\n\ntags:\n-\n"
        input = InputFile.yaml_file(hiiro: h, content: yaml_content, prefix: 'task-tag-')
        input.edit
        parsed = input.parsed_file
        input.cleanup
        selected = Array(parsed&.dig('tasks')).map(&:to_s).reject(&:empty?)
        new_tags = Array(parsed&.dig('tags')).map(&:to_s).reject(&:empty?)
        if selected.empty? || new_tags.empty?
          puts "Aborted: need at least one task and one tag"
          next
        end
        selected.each { |n| tag_store.add(n, *new_tags); puts "Tagged #{n} with: #{new_tags.join(', ')}" }
      else
        task_name = opts.args[0] || tm.current_task&.name
        tag_names = opts.args[1..]
        if task_name.nil? || tag_names.empty?
          puts "Usage: h task tag [task_name] <tag> [tag2 ...]"
          next
        end
        result = tag_store.add(task_name, *tag_names)
        puts "Tagged #{task_name} with: #{tag_names.join(', ')}"
        puts "  Tags now: #{result.join(', ')}"
      end
    end

    h.add_subcmd(:untag) do |*raw_args|
      tag_store = Hiiro::Tags.new(:task)
      task_name = raw_args[0] || tm.current_task&.name
      tag_names = raw_args[1..]
      if task_name.nil?
        puts "Usage: h task untag [task_name] [tag ...]"
        next
      end
      tag_store.remove(task_name, *tag_names)
      puts tag_names.empty? ? "Cleared all tags from #{task_name}" : "Removed #{tag_names.join(', ')} from #{task_name}"
    end

    h.add_subcmd(:tags) do
      tag_store = Hiiro::Tags.new(:task)
      all       = tag_store.all
      if all.empty?
        puts "No tagged tasks."
        next
      end
      by_tag = Hash.new { |h2, k| h2[k] = [] }
      all.each { |task, tags| tags.each { |t| by_tag[t] << task } }
      by_tag.sort.each do |tag, tasks|
        puts "#{Hiiro::Tags.badges([tag])} (#{tasks.length})"
        tasks.each { |t| puts "  #{t}" }
      end
    end

    h.add_subcmd(:sparse) do |*args|
      opts = Hiiro::Options.parse(args) do
        flag(:list,    short: 'l', desc: 'list available sparse groups and their directories')
        flag(:disable, short: 'd', desc: 'disable sparse checkout on the current task worktree')
      end

      if opts.help
        puts opts.help_text
        exit 1
      end

      if opts.list
        groups = Hiiro::SparseGroups.load
        if groups.empty?
          puts "No sparse groups configured."
          puts "  Config: #{Hiiro::SparseGroups::FILE}"
          next
        end
        puts "Sparse groups:"
        groups.each do |name, dirs|
          puts "  #{name}"
          Array(dirs).each { |d| puts "    #{d}" }
        end
        next
      end

      task = tm.current_task
      unless task
        puts "Not in a task session"
        next
      end

      tree = tm.environment.find_tree(task.tree_name)
      path = tree&.path
      unless path
        puts "Could not find worktree path for task '#{task.name}'"
        next
      end

      if opts.disable
        Hiiro::Git.new(nil, path).disable_sparse_checkout(path)
        puts "Disabled sparse checkout for '#{task.name}'"
        next
      end

      group_names = opts.args
      if group_names.empty?
        current = `git -C #{Shellwords.shellescape(path)} sparse-checkout list 2>/dev/null`.strip
        if current.empty?
          puts "No sparse checkout active for '#{task.name}'."
          puts "  Usage: h task sparse <group>  (e.g. h task sparse default)"
          puts "  Groups: h task sparse -l"
        else
          puts "Sparse checkout for '#{task.name}':"
          current.split("\n").each { |d| puts "  #{d}" }
        end
        next
      end

      tm.apply_sparse_checkout(path, group_names)
    end

    h.add_subcmd(:start) do |*raw_args|
      opts = Hiiro::Options.parse(raw_args) do
        option(:sparse, short: :s, desc: 'Sparse checkout group (may be repeated)', multi: true)
      end
      task_name = opts.args[0]
      app_name  = opts.args[1]
      tm.start_task(task_name, app_name: app_name, sparse_groups: opts.sparse)
    end

    h.add_subcmd(:switch) do |*raw_args|
      opts = Hiiro::Options.parse(raw_args) do
        option(:force, short: :f, type: :flag, desc: 'Switch even if session is already attached')
      end
      task_name = opts.args[0]
      app_name  = opts.args[1]

      if task_name.nil?
        selected = tm.select_task_interactive
        next unless selected

        case selected
        when Hiiro::Tmux::Session
          if selected.attached? && !opts.force
            puts "Session '#{selected.name}' is already attached. Use -f to switch anyway."
            exit 1
          end
          h.start_tmux_session(selected.name)
          puts "Switched to session '#{selected.name}'"
          next
        when Hiiro::Task
          tm.switch_to_task(selected, app_name: app_name, force: opts.force)
          next
        end
      end

      task = tm.task_by_name(task_name)

      # If no task found, check for a matching tmux session
      unless task
        session = tm.environment.find_session(task_name)
        if session
          if session.attached? && !opts.force
            puts "Session '#{session.name}' is already attached. Use -f to switch anyway."
            exit 1
          end
          h.start_tmux_session(session.name)
          puts "Switched to session '#{session.name}'"
          next
        end
      end

      # If still no task/session found, check ~/proj/* directories by prefix
      unless task
        proj_dirs = Dir.glob(File.expand_path('~/proj/*/'))
        dir_names = proj_dirs.map { |d| File.basename(d) }
        result = Hiiro::Matcher.by_prefix(dir_names, task_name)
        if result.one?
          dir_name = result.first.item
          h.start_tmux_session(dir_name, start_directory: File.expand_path("~/proj/#{dir_name}"))
          puts "Switched to ~/proj/#{dir_name}"
          next
        elsif result.ambiguous?
          puts "Ambiguous match for '#{task_name}': #{result.matches.map(&:item).join(', ')}"
          exit 1
        end
      end

      tm.switch_to_task(task, app_name: app_name, force: opts.force)
    end

    h.add_subcmd(:app) do |app_name=nil|
      if app_name.nil?
        names = tm.environment.all_apps.map(&:name)
        app_name = h.fuzzyfind(names)
        next unless app_name
      end
      tm.open_app(app_name)
    end

    h.add_subcmd(:apps) { tm.list_apps }

    h.add_subcmd(:cd) do |*raw_args|
      opts = Hiiro::Options.parse(raw_args, &task_opts_block)
      task, positional = resolve_task.call(opts, opts.args)
      unless task
        puts "No task found"
        next
      end
      tree_path = tm.resolve_path(task)
      app_name = positional[0]
      if app_name.nil?
        tm.send_cd(tree_path)
      else
        result = tm.environment.app_matcher.find(app_name)
        unless result.match?
          STDERR.puts "App '#{app_name}' not found"
          next
        end
        tm.send_cd(File.join(tree_path, result.first.item.relative_path))
      end
    end

    h.add_subcmd(:path) do |*raw_args|
      opts = Hiiro::Options.parse(raw_args, &task_opts_block)

      if opts.all
        tm.filter_tasks(opts.args).each do |task|
          path = tm.resolve_path(task)
          puts path if path
        end
        next
      end

      task, positional = resolve_task.call(opts, opts.args)
      unless task
        STDERR.puts "No task found"
        next
      end
      tree_path = tm.resolve_path(task)

      app_name = positional[0]
      globs    = positional[1..]

      if app_name.nil?
        print tree_path
        next
      end

      result = tm.environment.app_matcher.find(app_name)
      unless result.match?
        STDERR.puts "App '#{app_name}' not found"
        next
      end
      app_path = File.join(tree_path, result.first.item.relative_path)

      if globs.empty?
        print app_path
        next
      end

      globs.each do |pattern|
        Dir.glob(File.join(app_path, pattern)).sort.each { |f| puts f }
      end
    end

    # Helper for branch/tree/session/name: when -a is set, print one
    # value per matching task; otherwise behave like the original
    # single-task lookup (positional task name or fuzzyfind).
    print_task_value = lambda do |raw_args, attr|
      opts = Hiiro::Options.parse(raw_args, &task_opts_block)
      if opts.all
        tm.filter_tasks(opts.args).each do |t|
          val = t.public_send(attr)
          puts val if val
        end
      else
        task_name = opts.task || opts.args.first
        print tm.value_for_task(task_name) { |t| t.public_send(attr) }
      end
    end

    h.add_subcmd(:branch)  { |*raw_args| print_task_value.call(raw_args, :branch) }
    h.add_subcmd(:tree)    { |*raw_args| print_task_value.call(raw_args, :tree_name) }
    h.add_subcmd(:session) { |*raw_args| print_task_value.call(raw_args, :session_name) }
    h.add_subcmd(:name)    { |*raw_args| print_task_value.call(raw_args, :name) }

    h.add_subcmd(:current) do
      task = tm.current_task
      next STDERR.puts("Not in a task") unless task
      print task.name
    end

    h.add_subcmd(:cbranch) do
      task = tm.current_task
      next STDERR.puts("Not in a task") unless task
      print task.branch if task.branch
    end

    h.add_subcmd(:ctree) do
      task = tm.current_task
      next STDERR.puts("Not in a task") unless task
      print task.tree_name if task.tree_name
    end

    h.add_subcmd(:csession) do
      task = tm.current_task
      next STDERR.puts("Not in a task") unless task
      print task.session_name if task.session_name
    end

    h.add_subcmd(:sh) do |*raw_args|
      require 'shellwords'
      sh_opts_block = proc {
        instance_exec(&task_opts_block)
        option(:session, short: :s, desc: 'Run in a new window in this tmux session')
      }
      opts = Hiiro::Options.parse(raw_args, &sh_opts_block)
      task, positional = resolve_task.call(opts, opts.args)
      unless task
        puts "Not in a task session (use -t or -f to specify)"
        next
      end
      path = tm.resolve_path(task)

      if opts.session
        session_name = opts.session
        window_args = ['tmux', 'new-window', '-t', session_name, '-c', path]
        window_args << positional.shelljoin unless positional.empty?
        system(*window_args)
        tmux_client.open_session(session_name)
      else
        Dir.chdir(path)
        positional.empty? ? exec(ENV['SHELL'] || 'zsh') : exec(*positional)
      end
    end

    h.add_subcmd(:status) { tm.status }
    h.add_subcmd(:st) { tm.status }

    h.add_subcmd(:save) { tm.save }

    h.add_subcmd(:prune) do |*raw_args|
      opts = Hiiro::Options.parse(raw_args) {
        flag(:force, short: :f, desc: 'Actually delete (default is dry-run)')
      }

      to_remove = tm.environment.all_tasks.select do |task|
        next true unless task.tree_name
        path = tm.resolve_path(task)
        path.nil? || !Dir.exist?(path)
      end

      if to_remove.empty?
        puts "No tasks to prune"
        next
      end

      to_remove.each do |task|
        path = task.tree_name ? tm.resolve_path(task) : '(no tree)'
        if opts.force
          tm.config.remove_task(task.name)
          puts "Pruned: #{task.name} (#{path})"
        else
          puts "Would prune: #{task.name} (#{path})"
        end
      end

      unless opts.force
        puts
        puts "Re-run with -f to actually delete."
      end
    end

    h.add_subcmd(:color) do
      task = tm.current_task
      unless task
        puts "Not in a task session"
        next
      end
      unless task.color_index
        puts "No color assigned to task '#{task.name}'"
        next
      end
      Hiiro::TaskColors.apply(task.session_name, task.color_index)
      colors = Hiiro::TaskColors.for_index(task.color_index)
      puts "Applied color theme #{task.color_index}: bg=#{colors[:bg]} fg=#{colors[:fg]}"
    end

    h.add_subcmd(:stop) do |task_name=nil|
      if task_name.nil?
        selected = tm.select_task_interactive
        next unless selected
        task_name = selected.name
      end
      task = tm.task_by_name(task_name)
      tm.stop_task(task)
    end

    h.add_subcmd(:resume) do |tree_name=nil|
      available = tm.environment.all_trees.reject { |t|
        tm.environment.all_tasks.any? { |task| task.tree_name == t.name }
      }

      if available.empty?
        puts "No available worktrees to resume"
        next
      end

      tree = if tree_name
        Hiiro::Matcher.new(available, :name).by_prefix(tree_name).first&.item
      else
        h.fuzzyfind_from_map(available.each_with_object({}) { |t, m| m[t.name] = t })
      end

      unless tree
        puts tree_name ? "No available worktree matching '#{tree_name}'" : "No worktree selected"
        next
      end

      tm.resume_task(tree)
    end

    h.add_subcmd(:edit) do
      h.edit_files(__FILE__)
    end

    h.add_subcmd(:todo) do |*todo_args|
      todo_manager = Hiiro::TodoManager.new
      task = tm.current_task

      task_info = if task
        {
          task_name: task.name,
          tree: task.tree_name,
          branch: task.branch,
          session: task.session_name
        }
      end

      todo_subcmd = todo_args.shift
      case todo_subcmd
      when 'ls', 'list', nil
        show_all = todo_args.delete('-a') || todo_args.delete('--all')
        items = if show_all
          todo_manager.all
        elsif task
          todo_manager.filter_by_task(task.name).select { |i| %w[not_started started].include?(i.status) }
        else
          todo_manager.active
        end

        if items.empty?
          puts task ? "No todo items for task '#{task.name}'." : "No todo items found."
        else
          puts todo_manager.list(items)
        end

      when 'add'
        if todo_args.empty?
          new_items = todo_manager.edit_items(task_info: task_info)
          if new_items.empty?
            puts "No items added."
            next
          end
          todo_manager.add_items(new_items)
          if new_items.length == 1
            puts "Added: #{todo_manager.format_item(new_items.first)}"
          else
            puts "Added #{new_items.length} items:"
            new_items.each { |item| puts "  #{todo_manager.format_item(item)}" }
          end
          next
        end

        tags = nil
        text_parts = []
        while todo_args.any?
          arg = todo_args.shift
          case arg
          when '-t', '--tags'
            tags = todo_args.shift
          else
            text_parts << arg
          end
        end
        text = text_parts.join(' ')
        item = todo_manager.add(text, tags: tags, task_info: task_info)
        puts "Added: #{todo_manager.format_item(item)}"

      when 'rm', 'remove'
        id_or_index = todo_args.shift
        unless id_or_index
          puts "Usage: h #{tm.scope} todo rm <id|index>"
          next
        end
        item = todo_manager.remove(id_or_index)
        puts item ? "Removed: #{item.text}" : "Item not found: #{id_or_index}"

      when 'start'
        id_or_index = todo_args.shift
        unless id_or_index
          puts "Usage: h #{tm.scope} todo start <id|index>"
          next
        end
        item = todo_manager.start(id_or_index)
        puts item ? "Started: #{todo_manager.format_item(item)}" : "Item not found: #{id_or_index}"

      when 'done'
        id_or_index = todo_args.shift
        unless id_or_index
          puts "Usage: h #{tm.scope} todo done <id|index>"
          next
        end
        item = todo_manager.done(id_or_index)
        puts item ? "Done: #{todo_manager.format_item(item)}" : "Item not found: #{id_or_index}"

      when 'skip'
        id_or_index = todo_args.shift
        unless id_or_index
          puts "Usage: h #{tm.scope} todo skip <id|index>"
          next
        end
        item = todo_manager.skip(id_or_index)
        puts item ? "Skipped: #{todo_manager.format_item(item)}" : "Item not found: #{id_or_index}"

      when 'search'
        query = todo_args.join(' ')
        if query.empty?
          puts "Usage: h #{tm.scope} todo search <query>"
          next
        end
        items = todo_manager.search(query)
        if items.empty?
          puts "No items matching: #{query}"
        else
          puts todo_manager.list(items)
        end

      else
        puts "Usage: h #{tm.scope} todo <ls|add|rm|start|done|skip|search> [args]"
      end
    end

    h.add_subcmd(:queue) do |*queue_args|
      task = tm.current_task
      task_info = if task
        {
          task_name: task.name,
          tree_name: task.tree_name,
          session_name: task.session_name
        }
      end

      q = Hiiro::Queue.current(parent_hiiro)
      Hiiro::Queue.build_hiiro(h, q, task_info: task_info).run
    end

    h.add_subcmd(:service) do |*svc_args|
      sm = Hiiro::ServiceManager.new
      Hiiro::ServiceManager.build_hiiro(h, sm, task_manager: tm).run
    end

    h.add_subcmd(:run) do |*run_args|
      rt = Hiiro::RunnerTool.new
      Hiiro::RunnerTool.build_hiiro(h, rt, git: parent_hiiro.git).run
    end

    h.add_subcmd(:file) do |*file_args|
      af = Hiiro::AppFiles.new
      Hiiro::AppFiles.build_hiiro(h, af, environment: tm.environment).run
    end

    h.add_subcmd(:prs) do |*args|
      exec('h', 'pr', *args)
    end
  end

  task_hiiro
end