hiiro 0.1.68 → 0.1.69

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3064cf620431cbe446ea9083ab57784fd509c37257f803624d9ed70d9448f10
-  data.tar.gz: 0b487eed0954f696eb5289aa2f6b205c87b96d87d112c93d7e1e6b2ef587c12e
+  metadata.gz: 70e0ff0419923a10f71567fafbb03fed3c13a31bd3b338acb018cfc9f3dce8ec
+  data.tar.gz: 4d20bf045c56dde0ec03fdd9b7d47b24cb73aba90cf1871c36ffd206fce46b61
 SHA512:
-  metadata.gz: 60c6e5dd58849a83302753253b9e075a501b86b1e2a56bf609122a5c159cfdbd70161df02170f761120a2c9c4c58f4067ff4f4aa2bfd959f4ef9e2265e4f6fde
-  data.tar.gz: 12e76894beac7a152c78afac0598b62230c15a8d90cfad04667b79e75f9dcd2cdab34130ffdcf75b63021fca783be080e43b30b42f997c8ff579f55b6e316df8
+  metadata.gz: 29229cc49ada8ecf12bc34075818a4300a7a1b9e88729893e7216c85023b3c0c4a79c3f13dc8218d35b8516724c7d730a35ba04707bf08165117265125046acd
+  data.tar.gz: 001d4cb6ba6f1c0bb912efb2fe952462136315a6358e61be0a5d8a322430d62b60ce1df22204cbd6af57d031e0f367c42a71d4d2972db732853f082886f307b6

data/bin/h-todo

@@ -0,0 +1,273 @@
+#!/usr/bin/env ruby
+
+require 'hiiro'
+
+tm = Hiiro::TodoManager.new
+o = Hiiro.init(*ARGV, todo_file: tm.todo_file)
+
+o.add_subcmd(:ls) do |*args|
+  show_all = args.delete('-a') || args.delete('--all')
+  status_filter = nil
+  tag_filter = nil
+  task_filter = nil
+
+  while args.any?
+    arg = args.shift
+    case arg
+    when '-s', '--status'
+      status_filter = args.shift
+    when '-t', '--tag'
+      tag_filter = args.shift
+    when '--task'
+      task_filter = args.shift
+    end
+  end
+
+  items = if status_filter
+    tm.filter_by_status(*status_filter.split(','))
+  elsif tag_filter
+    tm.filter_by_tag(tag_filter)
+  elsif task_filter
+    tm.filter_by_task(task_filter)
+  elsif show_all
+    tm.all
+  else
+    tm.active
+  end
+
+  if items.empty?
+    puts "No todo items found."
+  else
+    puts tm.list(items)
+  end
+end
+
+o.add_subcmd(:list) do |*args|
+  o.run_subcmd(:ls, *args)
+end
+
+o.add_subcmd(:add) do |*args|
+  if args.empty?
+    new_items = tm.edit_items
+    if new_items.empty?
+      puts "No items added."
+      next
+    end
+
+    tm.add_items(new_items)
+    if new_items.length == 1
+      puts "Added: #{tm.format_item(new_items.first)}"
+    else
+      puts "Added #{new_items.length} items:"
+      new_items.each { |item| puts "  #{tm.format_item(item)}" }
+    end
+    next
+  end
+
+  tags = nil
+  text_parts = []
+
+  while args.any?
+    arg = args.shift
+    case arg
+    when '-t', '--tags'
+      tags = args.shift
+    else
+      text_parts << arg
+    end
+  end
+
+  text = text_parts.join(' ')
+  if text.empty?
+    puts "Usage: h todo add <text> [-t tags]"
+    exit 1
+  end
+
+  item = tm.add(text, tags: tags)
+  puts "Added: #{tm.format_item(item)}"
+end
+
+o.add_subcmd(:rm) do |*args|
+  id_or_index = args.shift
+  if id_or_index.nil?
+    puts "Usage: h todo rm <id|index>"
+    exit 1
+  end
+
+  item = tm.remove(id_or_index)
+  if item
+    puts "Removed: #{item.text}"
+  else
+    puts "Item not found: #{id_or_index}"
+    exit 1
+  end
+end
+
+o.add_subcmd(:remove) do |*args|
+  o.run_subcmd(:rm, *args)
+end
+
+o.add_subcmd(:change) do |*args|
+  id_or_index = args.shift
+  if id_or_index.nil?
+    puts "Usage: h todo change <id|index> [--text TEXT] [--tags TAGS] [--status STATUS]"
+    exit 1
+  end
+
+  text = nil
+  tags = nil
+  status = nil
+
+  while args.any?
+    arg = args.shift
+    case arg
+    when '--text'
+      text = args.shift
+    when '--tags', '-t'
+      tags = args.shift
+    when '--status', '-s'
+      status = args.shift
+    else
+      text ||= ''
+      text = [text, arg, *args].join(' ').strip
+      break
+    end
+  end
+
+  item = tm.change(id_or_index, text: text, tags: tags, status: status)
+  if item
+    puts "Updated: #{tm.format_item(item)}"
+  else
+    puts "Item not found: #{id_or_index}"
+    exit 1
+  end
+end
+
+o.add_subcmd(:start) do |*args|
+  id_or_index = args.shift
+  if id_or_index.nil?
+    puts "Usage: h todo start <id|index>"
+    exit 1
+  end
+
+  item = tm.start(id_or_index)
+  if item
+    puts "Started: #{tm.format_item(item)}"
+  else
+    puts "Item not found: #{id_or_index}"
+    exit 1
+  end
+end
+
+o.add_subcmd(:done) do |*args|
+  id_or_index = args.shift
+  if id_or_index.nil?
+    puts "Usage: h todo done <id|index>"
+    exit 1
+  end
+
+  item = tm.done(id_or_index)
+  if item
+    puts "Done: #{tm.format_item(item)}"
+  else
+    puts "Item not found: #{id_or_index}"
+    exit 1
+  end
+end
+
+o.add_subcmd(:skip) do |*args|
+  id_or_index = args.shift
+  if id_or_index.nil?
+    puts "Usage: h todo skip <id|index>"
+    exit 1
+  end
+
+  item = tm.skip(id_or_index)
+  if item
+    puts "Skipped: #{tm.format_item(item)}"
+  else
+    puts "Item not found: #{id_or_index}"
+    exit 1
+  end
+end
+
+o.add_subcmd(:reset) do |*args|
+  id_or_index = args.shift
+  if id_or_index.nil?
+    puts "Usage: h todo reset <id|index>"
+    exit 1
+  end
+
+  item = tm.reset(id_or_index)
+  if item
+    puts "Reset: #{tm.format_item(item)}"
+  else
+    puts "Item not found: #{id_or_index}"
+    exit 1
+  end
+end
+
+o.add_subcmd(:search) do |*args|
+  query = args.join(' ')
+  if query.empty?
+    puts "Usage: h todo search <query>"
+    exit 1
+  end
+
+  items = tm.search(query)
+  if items.empty?
+    puts "No items matching: #{query}"
+  else
+    puts tm.list(items)
+  end
+end
+
+o.add_subcmd(:path) do |*args|
+  print tm.todo_file
+end
+
+o.add_subcmd(:editall) do |*args|
+  editor = ENV['EDITOR'] || 'safe_nvim' || 'nvim'
+  system(editor, tm.todo_file)
+end
+
+o.add_subcmd(:help) do |*args|
+  puts <<~HELP
+    Usage: h todo <command> [args]
+
+    Commands:
+      ls, list              List todo items (active by default)
+        -a, --all           Show all items including done/skip
+        -s, --status STATUS Filter by status (not_started,started,done,skip)
+        -t, --tag TAG       Filter by tag
+        --task TASK         Filter by task name
+
+      add [text] [-t tags]  Add todo item(s)
+                            With no args, opens editor for YAML input
+
+      rm, remove <id|index> Remove a todo item
+
+      change <id|index>     Modify a todo item
+        --text TEXT         New text
+        --tags TAGS         New tags
+        --status STATUS     New status
+
+      start <id|index>      Mark item as started
+      done <id|index>       Mark item as done
+      skip <id|index>       Mark item as skipped
+      reset <id|index>      Reset item to not_started
+
+      search <query>        Search items by text, tags, or task
+
+      path                  Print path to todo.yml
+      editall               Open todo.yml in editor
+
+    Status icons:
+      [ ] not_started
+      [>] started
+      [x] done
+      [-] skip
+  HELP
+end
+
+o.run

data/lib/hiiro/todo.rb

@@ -0,0 +1,337 @@
+require 'yaml'
+require 'fileutils'
+require 'securerandom'
+require 'tempfile'
+
+module Hiiro
+  class TodoItem
+    STATUSES = %w[not_started started done skip].freeze
+
+    attr_accessor :id, :text, :status, :tags
+    attr_accessor :task_name, :subtask_name, :tree, :branch, :session
+    attr_accessor :created_at, :updated_at
+
+    def initialize(
+      id: nil,
+      text:,
+      status: 'not_started',
+      tags: nil,
+      task_name: nil,
+      subtask_name: nil,
+      tree: nil,
+      branch: nil,
+      session: nil,
+      created_at: nil,
+      updated_at: nil
+    )
+      @id = id || SecureRandom.hex(4)
+      @text = text
+      @status = STATUSES.include?(status) ? status : 'not_started'
+      @tags = tags
+      @task_name = task_name
+      @subtask_name = subtask_name
+      @tree = tree
+      @branch = branch
+      @session = session
+      @created_at = created_at || Time.now.to_s
+      @updated_at = updated_at || @created_at
+    end
+
+    def tags_list
+      return [] if tags.nil? || tags.empty?
+      tags.split(',').map(&:strip)
+    end
+
+    def has_tag?(tag)
+      tags_list.any? { |t| t.downcase == tag.downcase }
+    end
+
+    def add_tag(tag)
+      current = tags_list
+      return if current.any? { |t| t.downcase == tag.downcase }
+      current << tag
+      @tags = current.join(', ')
+    end
+
+    def remove_tag(tag)
+      current = tags_list.reject { |t| t.downcase == tag.downcase }
+      @tags = current.empty? ? nil : current.join(', ')
+    end
+
+    def has_task_info?
+      !task_name.nil? || !subtask_name.nil?
+    end
+
+    def full_task_name
+      return nil unless has_task_info?
+      subtask_name ? "#{task_name}/#{subtask_name}" : task_name
+    end
+
+    def update_status(new_status)
+      return false unless STATUSES.include?(new_status)
+      @status = new_status
+      @updated_at = Time.now.to_s
+      true
+    end
+
+    def to_h
+      h = {
+        'id' => id,
+        'text' => text,
+        'status' => status,
+        'created_at' => created_at,
+        'updated_at' => updated_at
+      }
+      h['tags'] = tags if tags && !tags.empty?
+      h['task_name'] = task_name if task_name
+      h['subtask_name'] = subtask_name if subtask_name
+      h['tree'] = tree if tree
+      h['branch'] = branch if branch
+      h['session'] = session if session
+      h
+    end
+
+    def self.from_h(h)
+      new(
+        id: h['id'],
+        text: h['text'],
+        status: h['status'],
+        tags: h['tags'],
+        task_name: h['task_name'],
+        subtask_name: h['subtask_name'],
+        tree: h['tree'],
+        branch: h['branch'],
+        session: h['session'],
+        created_at: h['created_at'],
+        updated_at: h['updated_at']
+      )
+    end
+
+    def match?(query)
+      query = query.downcase
+      text.downcase.include?(query) ||
+        tags_list.any? { |t| t.downcase.include?(query) } ||
+        (task_name && task_name.downcase.include?(query)) ||
+        (subtask_name && subtask_name.downcase.include?(query)) ||
+        (tree && tree.downcase.include?(query)) ||
+        (branch && branch.downcase.include?(query))
+    end
+  end
+
+  class TodoManager
+    TODO_FILE = File.join(Dir.home, '.config', 'hiiro', 'todo.yml')
+
+    ITEM_TEMPLATE = {
+      'text' => '',
+      'status' => 'not_started',
+      'tags' => nil
+    }.freeze
+
+    attr_reader :items, :todo_file
+
+    def initialize(file_path: nil)
+      @todo_file = file_path || TODO_FILE
+      @file_path = @todo_file
+      @items = load_items
+    end
+
+    # --- High-level API ---
+
+    def all
+      items
+    end
+
+    def find(id)
+      items.find { |item| item.id == id || item.id.start_with?(id) }
+    end
+
+    def find_by_index(index)
+      items[index.to_i]
+    end
+
+    def add(text, tags: nil, task_info: nil)
+      item = TodoItem.new(
+        text: text,
+        tags: tags,
+        task_name: task_info&.dig(:task_name),
+        subtask_name: task_info&.dig(:subtask_name),
+        tree: task_info&.dig(:tree),
+        branch: task_info&.dig(:branch),
+        session: task_info&.dig(:session)
+      )
+      @items << item
+      save
+      item
+    end
+
+    def edit_items(items_to_edit = nil, task_info: nil)
+      items_array = if items_to_edit.nil?
+        [ITEM_TEMPLATE.dup]
+      elsif items_to_edit.is_a?(Array)
+        items_to_edit.map { |item| item.is_a?(TodoItem) ? editable_hash(item) : item }
+      else
+        [items_to_edit.is_a?(TodoItem) ? editable_hash(items_to_edit) : items_to_edit]
+      end
+
+      tmpfile = Tempfile.new(['todo-edit-', '.yml'])
+      tmpfile.write(items_array.to_yaml)
+      tmpfile.close
+
+      editor = ENV['EDITOR'] || 'safe_nvim' || 'nvim'
+      system(editor, tmpfile.path)
+
+      updated_data = YAML.safe_load_file(tmpfile.path)
+      tmpfile.unlink
+
+      return [] if updated_data.nil?
+
+      updated_array = updated_data.is_a?(Array) ? updated_data : [updated_data]
+      updated_array.filter_map do |h|
+        next if h['text'].nil? || h['text'].to_s.strip.empty?
+        TodoItem.new(
+          text: h['text'],
+          status: h['status'] || 'not_started',
+          tags: h['tags'],
+          task_name: task_info&.dig(:task_name),
+          subtask_name: task_info&.dig(:subtask_name),
+          tree: task_info&.dig(:tree),
+          branch: task_info&.dig(:branch),
+          session: task_info&.dig(:session)
+        )
+      end
+    end
+
+    def add_items(new_items)
+      @items.concat(new_items)
+      save
+      new_items
+    end
+
+    def remove(id_or_index)
+      item = resolve_item(id_or_index)
+      return nil unless item
+      @items.delete(item)
+      save
+      item
+    end
+
+    def change(id_or_index, text: nil, tags: nil, status: nil)
+      item = resolve_item(id_or_index)
+      return nil unless item
+
+      item.text = text if text
+      item.tags = tags if tags
+      item.update_status(status) if status
+      item.updated_at = Time.now.to_s
+      save
+      item
+    end
+
+    def start(id_or_index)
+      change_status(id_or_index, 'started')
+    end
+
+    def done(id_or_index)
+      change_status(id_or_index, 'done')
+    end
+
+    def skip(id_or_index)
+      change_status(id_or_index, 'skip')
+    end
+
+    def reset(id_or_index)
+      change_status(id_or_index, 'not_started')
+    end
+
+    def search(query)
+      items.select { |item| item.match?(query) }
+    end
+
+    def filter_by_status(*statuses)
+      items.select { |item| statuses.include?(item.status) }
+    end
+
+    def filter_by_tag(tag)
+      items.select { |item| item.has_tag?(tag) }
+    end
+
+    def filter_by_task(task_name)
+      items.select { |item| item.task_name == task_name || item.full_task_name == task_name }
+    end
+
+    def active
+      filter_by_status('not_started', 'started')
+    end
+
+    def completed
+      filter_by_status('done', 'skip')
+    end
+
+    # --- List display ---
+
+    def list(items_to_show = nil, show_all: false)
+      items_to_show ||= show_all ? all : active
+      return "No todo items found." if items_to_show.empty?
+
+      lines = []
+      items_to_show.each_with_index do |item, idx|
+        lines << format_item(item, idx)
+      end
+      lines.join("\n")
+    end
+
+    def format_item(item, index = nil)
+      status_icon = case item.status
+        when 'not_started' then '[ ]'
+        when 'started' then '[>]'
+        when 'done' then '[x]'
+        when 'skip' then '[-]'
+      end
+
+      idx_str = index ? format('%2d.', index) : '   '
+      line = "#{idx_str} #{status_icon} #{item.text}"
+      line += "  [#{item.tags}]" if item.tags && !item.tags.empty?
+      line += "  (#{item.full_task_name})" if item.has_task_info?
+      line
+    end
+
+    private
+
+    def resolve_item(id_or_index)
+      if id_or_index.is_a?(Integer) || id_or_index =~ /^\d+$/
+        find_by_index(id_or_index.to_i)
+      else
+        find(id_or_index)
+      end
+    end
+
+    def change_status(id_or_index, status)
+      item = resolve_item(id_or_index)
+      return nil unless item
+      item.update_status(status)
+      save
+      item
+    end
+
+    def editable_hash(item)
+      {
+        'text' => item.text,
+        'status' => item.status,
+        'tags' => item.tags
+      }
+    end
+
+    def load_items
+      return [] unless File.exist?(@file_path)
+
+      data = YAML.safe_load_file(@file_path) || {}
+      (data['todos'] || []).map { |h| TodoItem.from_h(h) }
+    end
+
+    def save
+      FileUtils.mkdir_p(File.dirname(@file_path))
+      data = { 'todos' => items.map(&:to_h) }
+      File.write(@file_path, YAML.dump(data))
+    end
+  end
+end

data/lib/hiiro/version.rb

@@ -1,3 +1,3 @@
 class Hiiro
-  VERSION = "0.1.68"
+  VERSION = "0.1.69"
 end

data/lib/hiiro.rb

@@ -9,6 +9,7 @@ require_relative "hiiro/git"
 require_relative "hiiro/history"
 require_relative "hiiro/options"
 require_relative "hiiro/sk"
+require_relative "hiiro/todo"
 
 class String
   def underscore(camel_cased_word=self)
@@ -98,6 +99,10 @@ class Hiiro
     Hiiro.init(bin_name:, args:, **kwargs, &block)
   end
 
+  def todo_manager
+    @todo_manager ||= TodoManager.new
+  end
+
   def history
     @history ||= History.new
   end

data/plugins/tasks.rb

@@ -1,5 +1,6 @@
 require 'yaml'
 require 'fileutils'
+require_relative '../lib/hiiro/todo'
 
 WORK_DIR = File.join(Dir.home, 'work')
 REPO_PATH = File.join(WORK_DIR, '.bare')
@@ -923,6 +924,125 @@ module Tasks
       h.add_subcmd(:edit) do
         system(ENV['EDITOR'] || 'nvim', __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.subtask? ? task.parent_name : task.name,
+            subtask_name: task.subtask? ? task.short_name : nil,
+            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')
+          # Default to filtering by current task unless -a or --all is used
+          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
     end
 
     attach_methods task_hiiro, tm

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hiiro
 version: !ruby/object:Gem::Version
-  version: 0.1.68
+  version: 0.1.69
 platform: ruby
 authors:
 - Joshua Toyota
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-10 00:00:00.000000000 Z
+date: 2026-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -85,6 +85,7 @@ files:
 - bin/h-serve
 - bin/h-session
 - bin/h-sha
+- bin/h-todo
 - bin/h-video
 - bin/h-window
 - bin/h-wtree
@@ -111,6 +112,7 @@ files:
 - lib/hiiro/options.rb
 - lib/hiiro/prefix_matcher.rb
 - lib/hiiro/sk.rb
+- lib/hiiro/todo.rb
 - lib/hiiro/version.rb
 - notes
 - plugins/notify.rb