taf-cli 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 429fcf82dcb51d4be79dd52ca058902436ad9df756e7361d43482df5243af033
+  data.tar.gz: 64d11156b021003106371ebaffca36ab0e44887a4b05758bebb91dd7ade57581
+SHA512:
+  metadata.gz: ec40f282568d9937f5afebc5f816c0d98aae0925035df9bbe188fd86f8c042e5e62de61e1139473b8d84a9db23c6eb1b2341b13a36fbc704eb2a2550f6a47b84
+  data.tar.gz: cb3278413cca7a2eb654b4b8dabef3a7ee09aff292b7333daaf1300e28eaffef20207bd592fbea601b3f1056e51f1d292574a6f800be4ddaeebead1d838a738a

data/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-10-22
+
+### Changed
+- Initial stable release (bumped to 1.0.0 to avoid conflicts with previously yanked versions)
+
+## [0.1.0] - 2025-10-22
+
+### Added
+- Initial release of taf (Travail À Faire)
+- Markdown-based todo list storage
+- Tag-based organization of tasks
+- Hierarchical task structure (parent-child relationships)
+- Toggle task completion status
+- Delete tasks
+- Edit file directly in $EDITOR
+- Undo functionality with automatic backups
+- Cleanup command to sort todos before done items
+- Purge command to remove all completed tasks
+- Default file path to ~/taf.md (optional -f flag)
+
+[0.1.0]: https://github.com/jmoniatte/taf/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jean Moniatte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# TAF - Travail À Faire
+
+A simple CLI todo list manager written in Ruby.
+
+`taf` is a lightweight command-line tool that helps you manage your todos in a markdown file. It supports hierarchical task organization with tags, parent-child relationships, and various management commands.
+
+## Features
+
+* Store todos in a simple markdown format
+* Organize tasks with tags
+* Create hierarchical todos (parent-child relationships)
+* Toggle task completion status
+* Undo changes with automatic backups
+* Cleanup and purge completed tasks
+
+## Installation
+
+### Prerequisites
+
+Ensure you have Ruby 2.6 or later installed:
+
+```bash
+ruby --version
+```
+
+### Install from RubyGems
+
+```bash
+gem install taf-cli
+```
+
+This installs the `taf` command.
+
+### Verify Installation
+
+```bash
+taf --help
+```
+
+### Install from Source (Alternative)
+
+If you want to install from source:
+
+```bash
+git clone https://github.com/jmoniatte/taf.git
+cd taf
+gem build taf.gemspec
+gem install ./taf-cli-1.0.0.gem
+```
+
+## Usage
+
+By default, `taf` uses `~/taf.md` as the todo file. You can specify a different file with the `-f` option.
+
+### Basic Commands
+
+**View all todos:**
+```bash
+taf
+```
+
+**Add a todo with a tag:**
+```bash
+taf Buy groceries @shopping
+```
+
+**Add a todo (uses "Untagged" as default tag):**
+```bash
+taf Fix the bug in authentication
+```
+
+**View todos for a specific tag:**
+```bash
+taf @shopping
+```
+
+**Add a child todo under a parent:**
+```bash
+taf Buy milk @12
+# This adds "Buy milk" as a child of item @12
+```
+
+**Toggle a todo's completion status:**
+```bash
+taf -t @12
+```
+
+**Delete a todo:**
+```bash
+taf -D @12
+```
+
+**Edit the file manually:**
+```bash
+taf -e
+# Opens the file $EDITOR (or vim by default)
+```
+
+**Undo the last change:**
+```bash
+taf -u
+```
+
+**Cleanup (sort todos before done items):**
+```bash
+taf -c
+```
+
+**Purge all completed tasks:**
+```bash
+taf -P
+```
+
+### Using a Custom File
+
+```bash
+taf -f /path/to/my-todos.md "New task" @work
+```
+
+## Markdown Format
+
+The todo file is stored in a simple markdown format:
+
+```markdown
+# shopping
+- [ ] Buy groceries
+  - [ ] Milk
+  - [x] Bread
+- [x] Get coffee
+
+# work
+- [ ] Review pull request
+- [ ] Write documentation
+```
+
+- Tags are markdown headers (`# tagname`)
+- Uncompleted todos use `- [ ]`
+- Completed todos use `- [x]`
+- Child items are indented with 2 spaces per level
+
+## Options
+
+```
+Usage: taf [options] [message]
+Options:
+  -f, --file FILE      Path to the taf markdown file (default: ~/taf.md)
+  -h, --help           Show help
+  -t @LINE_ID          Toggle status for line id
+  -D @LINE_ID          Delete the specified line id
+  -e, --edit           Open the file in $EDITOR for manual edits
+  -u, --undo           Undo the last change
+  -c, --cleanup        Sort items (todo items before done)
+  -P, --purge          Delete all done items
+
+Message:
+  text @tag            Records todo for @tag
+  text @ID             Records todo as child of parent ID
+  @tag                 Displays todos for @tag
+```
+
+## Examples
+
+```bash
+# Start fresh
+taf "Plan vacation" @personal
+
+# Add related subtasks
+taf "Book flights" @1
+taf "Reserve hotel" @1
+taf "Research activities" @1
+
+# Add work tasks
+taf "Review code" @work
+taf "Update documentation" @work
+
+# Mark a task as done
+taf -t @2
+
+# View all tasks
+taf
+
+# View only personal tasks
+taf @personal
+
+# Clean up completed tasks
+taf -P
+```
+
+## License
+
+MIT

data/bin/taf

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/taf'
+
+CLI.new(ARGV).run

data/lib/taf/ansi_colors.rb

@@ -0,0 +1,27 @@
+module AnsiColors
+  ANSI_RESET = "\u001B[0m".freeze
+  ANSI_BLACK = "\u001B[30m".freeze
+  ANSI_RED = "\u001B[31m".freeze
+  ANSI_GREEN = "\u001B[32m".freeze
+  ANSI_YELLOW = "\u001B[33m".freeze
+  ANSI_BLUE = "\u001B[34m".freeze
+  ANSI_PURPLE = "\u001B[35m".freeze
+  ANSI_CYAN = "\u001B[36m".freeze
+  ANSI_WHITE = "\u001B[97m".freeze
+  ANSI_GREY = "\u001B[37m".freeze
+  ANSI_HIGHLIGHT = "\u001B[43;30m".freeze
+  ANSI_DEFAULT = "\u001B[39m".freeze
+end
+
+class String
+  AnsiColors.constants.each do |const_name|
+    next if const_name == :ANSI_RESET
+
+    color_name = const_name.to_s.sub(/^ANSI_/, '').downcase
+    color_code = AnsiColors.const_get(const_name)
+
+    define_method(color_name) do
+      "#{color_code}#{self}#{AnsiColors::ANSI_RESET}"
+    end
+  end
+end

data/lib/taf/cli.rb

@@ -0,0 +1,207 @@
+require 'optparse'
+require_relative 'models/taf'
+require_relative 'ansi_colors'
+require_relative 'taf_helper'
+
+# Handles CLI argument parsing and command execution
+class CLI
+  def initialize(args)
+    @args = args
+    @mode = :default
+    @file = nil
+    @message = nil
+    @taf = nil
+  end
+
+  def run
+    parse_options
+    validate_options
+    execute_command
+  end
+
+  private
+
+  def parse_options
+    parser = create_option_parser
+
+    begin
+      parser.parse!(@args)
+      # Only set @message from remaining args if not already set by option handler
+      @message ||= @args.join(" ")
+    rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+      puts e.message.red
+      puts parser.help.red
+      exit 1
+    end
+  end
+
+  def create_option_parser
+    OptionParser.new do |opts|
+      opts.banner = "Usage: taf [options] [message]"
+      opts.separator "Options:"
+
+      opts.on("-f FILE", "--file FILE", "Path to the taf markdown file (default: ~/taf.md)") do |file|
+        @file = file
+      end
+
+      opts.on("-h", "--help", "Show help") do
+        @mode = :help
+      end
+
+      opts.on("-t @LINE_ID", "Toggle status for line id") do |line_id|
+        @mode = :toggle
+        @message = line_id
+      end
+
+      opts.on("-D @LINE_ID", "Delete the specified line id") do |line_id|
+        @mode = :delete
+        @message = line_id
+      end
+
+      opts.on("-e", "--edit", "Open the file in $EDITOR for manual edits") do
+        @mode = :edit
+      end
+
+      opts.on("-u", "--undo", "Undo the last change") do
+        @mode = :undo
+      end
+
+      opts.on("-c", "--cleanup", "Sort items (todo items before done)") do
+        @mode = :cleanup
+      end
+
+      opts.on("-P", "--purge", "Delete all done items") do
+        @mode = :purge
+      end
+
+      opts.separator "Message:"
+      opts.separator "    text @tag                        Records todo for @tag"
+      opts.separator "    text @ID                         Records todo as child of parent ID"
+      opts.separator "    @tag                             Displays todos for @tag"
+    end
+  end
+
+  def validate_options
+    # Set default file if not specified
+    @file ||= File.expand_path("~/taf.md") unless @mode == :help
+
+    @taf = Taf.new(@file) if @file
+  end
+
+  def execute_command
+    case @mode
+    when :help
+      puts create_option_parser.help
+    when :toggle
+      toggle_command
+    when :delete
+      delete_command
+    when :edit
+      edit_command
+    when :undo
+      undo_command
+    when :cleanup
+      cleanup_command
+    when :purge
+      purge_command
+    when :default
+      default_command
+    end
+  end
+
+  def toggle_command
+    _text, _tag, line_id = TafHelper.parse_message(@message)
+    unless line_id
+      puts "Error: Invalid line ID format. Use @NUMBER (e.g., @21)".red
+      exit 1
+    end
+
+    item = @taf.find_item_by_id(line_id)
+    unless item
+      puts "Error: Item with id #{line_id} not found".red
+      exit 1
+    end
+    item_signatures = @taf.toggle(item)
+    @taf = Taf.new(@file)
+    system("clear")
+    @taf.show_all(highlight_signatures: item_signatures)
+  end
+
+  def delete_command
+    _text, _tag, line_id = TafHelper.parse_message(@message)
+    unless line_id
+      puts "Error: Invalid line ID format. Use @NUMBER (e.g., @21)".red
+      exit 1
+    end
+
+    item = @taf.find_item_by_id(line_id)
+    unless item
+      puts "Error: Item with id #{line_id} not found".red
+      exit 1
+    end
+    @taf.delete(item)
+    @taf = Taf.new(@file)
+    system("clear")
+    @taf.show_all
+  end
+
+  def edit_command
+    Taf.backup(@file)
+    system("#{ENV['EDITOR'] || 'vim'} #{@file}")
+    @taf = Taf.new(@file)
+    system("clear")
+    @taf.show_all
+    puts "Taf file saved".green
+  end
+
+  def undo_command
+    begin
+      Taf.restore(@file)
+      @taf = Taf.new(@file)
+      system("clear")
+      @taf.show_all
+      puts "Undo successful".green
+    rescue ArgumentError => e
+      puts "Error: #{e.message}".red
+      exit 1
+    end
+  end
+
+  def cleanup_command
+    @taf.cleanup
+    @taf = Taf.new(@file)
+    system("clear")
+    @taf.show_all
+    puts "Cleanup complete".green
+  end
+
+  def purge_command
+    @taf.purge
+    @taf = Taf.new(@file)
+    system("clear")
+    @taf.show_all
+    puts "Purge complete".green
+  end
+
+  def default_command
+    text, tag, parent_id = TafHelper.parse_message(@message)
+    if tag.nil? && text.nil? && parent_id.nil?
+      system("clear")
+      @taf.show_all
+    elsif text.nil?
+      system("clear")
+      @taf.show_tag(tag)
+    else
+      begin
+        todo_signatures = @taf.add_todo(text, tag: tag, parent_id: parent_id)
+
+        @taf = Taf.new(@file)
+        system("clear")
+        @taf.show_all(highlight_signatures: todo_signatures)
+      rescue ArgumentError => e
+        puts "Error: #{e.message}".red
+        exit 1
+      end
+    end
+  end
+end

data/lib/taf/markdown_adapter.rb

@@ -0,0 +1,91 @@
+module MarkdownAdapter
+  require_relative 'taf_helper'
+  require_relative 'models/todo'
+
+  # Markdown format constants
+  TAG_PREFIX = "#".freeze
+  TODO_PREFIX = "- [ ]".freeze
+  DONE_PREFIX = "- [x]".freeze
+  INDENT_SIZE = 2  # Number of spaces per indent level
+
+  # Reads markdown and returns data as a tree structure
+  def self.read(file)
+    return {} unless File.exist?(file)
+
+    rows = File
+      .readlines(file)
+      .map(&:rstrip)
+      .reject { |line| line.nil? || line.empty? }
+
+    {}.tap do |data|
+      tag = TafHelper::DEFAULT_TAG
+      # Stack to track parent at each indent level
+      stack = []
+
+      rows.each do |row|
+        if row.start_with?("#{TAG_PREFIX} ")
+          tag = row.delete_prefix("#{TAG_PREFIX} ")
+          data[tag] ||= []
+          stack = []  # Reset stack for new tag
+        elsif tag.nil?
+          next
+        else
+          # Calculate indent level from leading spaces
+          leading_spaces = row[/^\s*/].length
+          indent_level = leading_spaces / INDENT_SIZE
+          stripped_row = row.lstrip
+
+          # Trim stack to current indent level
+          stack = stack[0...indent_level]
+
+          # Determine parent
+          parent = indent_level > 0 ? stack[indent_level - 1] : nil
+
+          # Create the item
+          status = stripped_row.start_with?("#{TODO_PREFIX} ") ? "todo" : "done"
+          prefix = status == "todo" ? TODO_PREFIX : DONE_PREFIX
+          item = Todo.new(
+            status: status,
+            text: stripped_row.delete_prefix("#{prefix} "),
+            children: [],
+            parent: parent
+          )
+
+          # Add to parent's children or to root
+          if indent_level == 0
+            data[tag] << item
+          else
+            parent.children << item
+          end
+
+          # Push current item onto stack
+          stack[indent_level] = item
+        end
+      end
+    end
+  end
+
+  # Writes data to markdown file (flattens tree structure)
+  def self.write(file, data)
+    rows = []
+    data.each do |tag, items|
+      rows << "#{TAG_PREFIX} #{tag}"
+      items.each do |item|
+        flatten_item(item, 0, rows)
+      end
+    end
+    File.write(file, rows.join("\n"))
+  end
+
+  # Recursively flattens a tree item and its children
+  def self.flatten_item(item, indent_level, rows)
+    prefix = item.status == "todo" ? TODO_PREFIX : DONE_PREFIX
+    indent = ' ' * (indent_level * INDENT_SIZE)
+    rows << "#{indent}#{prefix} #{item.text}"
+
+    # Recursively add children
+    item.children.each do |child|
+      flatten_item(child, indent_level + 1, rows)
+    end
+  end
+end

data/lib/taf/models/taf.rb

@@ -0,0 +1,258 @@
+require 'fileutils'
+require_relative '../markdown_adapter'
+require_relative '../taf_helper'
+require_relative '../terminal_presenter'
+require_relative 'todo'
+
+class Taf
+  def initialize(file)
+    @file = file
+    @taf = MarkdownAdapter.read(file)
+    assign_indices
+    @presenter = TerminalPresenter.new
+  end
+
+  # Creates a backup of the file
+  def self.backup(file)
+    FileUtils.cp(file, "#{file}.backup") if File.exist?(file)
+  end
+
+  # Restores the backup file and deletes it
+  def self.restore(file)
+    backup_file = "#{file}.backup"
+    unless File.exist?(backup_file)
+      raise ArgumentError, "No backup file found"
+    end
+
+    FileUtils.cp(backup_file, file)
+    File.delete(backup_file)
+  end
+
+  # Adds a new item
+  def add_todo(text, tag: nil, parent_id: nil)
+    # Avoids flag typos
+    raise ArgumentError, "Text must be #{Todo::MIN_LENGTH} or more characters" unless text.size >= Todo::MIN_LENGTH
+
+    # Default tag if neither tag nor parent specified
+    if tag.nil? && parent_id.nil?
+      tag = TafHelper::DEFAULT_TAG
+    end
+
+    changed = []
+    if parent_id
+      parent_item = find_item_by_id(parent_id)
+      unless parent_item
+        raise ArgumentError, "Parent with id #{parent_id} not found"
+      end
+
+      new_item = Todo.new(
+        status: "todo",
+        text: text,
+        children: [],
+        parent: parent_item
+      )
+      parent_item.children << new_item
+      changed = mark_ancestors_todo(parent_item)
+    else
+      new_item = Todo.new(
+        status: "todo",
+        text: text,
+        children: []
+      )
+      if @taf[tag]
+        # Tag exists, append to root level
+        @taf[tag] << new_item
+      else
+        # Create new tag
+        @taf[tag] = [new_item]
+      end
+    end
+
+    changed << new_item
+    assign_indices
+    save
+
+    changed.map(&:signature)
+  end
+
+  # Shows given tag and its items
+  def show_tag(tag, highlight_signatures: nil)
+    @taf.each do |key, items|
+      next unless key == tag
+
+      @presenter.display_tag(key)
+      items.each do |item|
+        display_item_recursive(item, 0, highlight_signatures)
+      end
+      puts ""
+    end
+  end
+
+  # Shows all tags and items
+  def show_all(highlight_signatures: nil)
+    @taf.each do |key, items|
+      @presenter.display_tag(key)
+      items.each do |item|
+        display_item_recursive(item, 0, highlight_signatures)
+      end
+      puts ""
+    end
+  end
+
+  # Recursively displays an item and its children with proper indentation
+  def display_item_recursive(item, indent_level, highlight_signatures)
+    @presenter.display_todo(item, indent_level, highlighted: highlight_signatures&.include?(item.signature))
+    item.children.each do |child|
+      display_item_recursive(child, indent_level + 1, highlight_signatures)
+    end
+  end
+
+  # Toggles the status of the item
+  # Toggles ancestors and descendants accordingly
+  def toggle(item)
+    item.status = item.status == "done" ? "todo" : "done"
+
+    affected_items = [item]
+    if item.status == "done"
+      affected_items.concat(mark_descendants_done(item))
+    elsif item.parent
+      affected_items.concat(mark_ancestors_todo(item.parent))
+    end
+
+    save
+    affected_items.map(&:signature)
+  end
+
+  # Recursively marks all descendants as done and returns those that changed
+  def mark_descendants_done(item)
+    changed = []
+    item.children.each do |child|
+      changed << child if child.status != "done"
+      child.status = "done"
+      changed.concat(mark_descendants_done(child))
+    end
+    changed
+  end
+
+  # Recursively marks all ancestors as todo and returns those that changed
+  def mark_ancestors_todo(item)
+    changed = []
+    current = item
+    while current
+      changed << current if current.status != "todo"
+      current.status = "todo"
+      current = current.parent
+    end
+    changed
+  end
+
+  # Deletes the item (and all its children)
+  def delete(item)
+    if item.parent
+      # Remove from parent's children
+      item.parent.children.delete(item)
+    else
+      # Remove from root level
+      @taf.each_value do |items|
+        if items.delete(item)
+          break
+        end
+      end
+    end
+
+    save
+  end
+
+  # Finds a todo item by its index across all tags (searches recursively)
+  def find_item_by_id(id)
+    @taf.each_value do |items|
+      items.each do |item|
+        result = find_in_subtree(item, id)
+        return result if result
+      end
+    end
+    nil
+  end
+
+  # Sorts all items (todo items before done items) and saves
+  def cleanup
+    # Sort items: within each parent, todo items before done items
+    @taf.each_value do |items|
+      items.each do |item|
+        sort_children_recursive(item)
+      end
+      # Sort root level items
+      items.sort_by! { |item| item.status == "done" ? 1 : 0 }
+    end
+
+    save
+  end
+
+  # Deletes all done items (and their children) and saves
+  def purge
+    @taf.each_value do |items|
+      items.reject! { |item| item.status == "done" }
+      items.each do |item|
+        purge_done_children(item)
+      end
+    end
+
+    save
+  end
+
+  private
+
+  # Recursively removes done children from an item
+  def purge_done_children(item)
+    item.children.reject! { |child| child.status == "done" }
+    item.children.each do |child|
+      purge_done_children(child)
+    end
+  end
+
+  # Recursively searches for an item in a subtree
+  def find_in_subtree(item, id)
+    return item if item.idx == id
+
+    item.children.each do |child|
+      result = find_in_subtree(child, id)
+      return result if result
+    end
+    nil
+  end
+
+  # Removes empty tags and writes to file
+  def save
+    @taf.delete_if { |_tag, items| items.empty? }
+    self.class.backup(@file)
+    MarkdownAdapter.write(@file, @taf)
+  end
+
+  # Recursively sorts children: todo before done
+  def sort_children_recursive(item)
+    item.children.sort_by! { |child| child.status == "done" ? 1 : 0 }
+    item.children.each do |child|
+      sort_children_recursive(child)
+    end
+  end
+
+  # Assigns sequential indices to all todo items using depth-first traversal
+  def assign_indices
+    idx = 0
+    @taf.each_value do |items|
+      items.each do |item|
+        idx = assign_index_recursive(item, idx)
+      end
+    end
+  end
+
+  # Recursively assigns indices in depth-first order
+  def assign_index_recursive(item, idx)
+    idx += 1
+    item.idx = idx
+    item.children.each do |child|
+      idx = assign_index_recursive(child, idx)
+    end
+    idx
+  end
+end

data/lib/taf/models/todo.rb

@@ -0,0 +1,28 @@
+require 'digest'
+
+# Represents a single todo item in a tree structure
+class Todo
+  attr_accessor :idx, :status, :text, :children, :parent
+
+  MIN_LENGTH = 3
+
+  def initialize(status:, text:, idx: nil, children: [], parent: nil)
+    @idx = idx
+    @status = status
+    @text = text
+    @children = children
+    @parent = parent
+  end
+
+  def done?
+    @status == "done"
+  end
+
+  def todo?
+    @status == "todo"
+  end
+
+  def signature
+    Digest::MD5.hexdigest("#{text}|#{parent&.text}")
+  end
+end

data/lib/taf/taf_helper.rb

@@ -0,0 +1,47 @@
+module TafHelper
+  DEFAULT_TAG = "Untagged".freeze
+
+  # Extracts text, tag, and parent_id from message
+  # Returns [text, tag, parent_id]
+  # - If @ID (numeric): parent_id is set, tag is nil
+  # - If @tag (alphanumeric): tag is set, parent_id is nil
+  # - Otherwise: both nil
+  def self.parse_message(message)
+    return [nil, nil, nil] if message.to_s.empty?
+
+    if (tag_only = message[/^@[A-Za-z0-9][A-Za-z0-9_-]*$/])
+      return parse_tag_or_parent(nil, tag_only)
+    end
+
+    tag = message[/ @[A-Za-z0-9][A-Za-z0-9_-]*$/]
+    if tag
+      text = message.sub(/ @[A-Za-z0-9][A-Za-z0-9_-]*$/, "")
+      text.strip!
+      parse_tag_or_parent(text, tag)
+    else
+      text = message.strip
+      [text, nil, nil]
+    end
+  end
+
+  # Determines if tag_string is a parent ID or a tag
+  def self.parse_tag_or_parent(text, tag_string)
+    cleaned = tag_string.strip.delete_prefix("@")
+
+    if cleaned.match?(/^\d+$/)
+      [text, nil, cleaned.to_i]
+    else
+      [text, tag_name(tag_string), nil]
+    end
+  end
+
+  # Transforms `@tag-name` to `Tag Name`
+  def self.tag_name(tag)
+    tag
+      .strip
+      .delete_prefix("@")
+      .split(/[-_]/)
+      .map(&:capitalize)
+      .join(" ")
+  end
+end

data/lib/taf/terminal_presenter.rb

@@ -0,0 +1,34 @@
+require_relative 'ansi_colors'
+require_relative 'markdown_adapter'
+
+# Handles terminal display formatting for items
+class TerminalPresenter
+  # Display format constants
+  TAG_PREFIX = "#".freeze
+  TODO_PREFIX = "- [ ]".freeze
+  DONE_PREFIX = "- [x]".freeze
+  INDENT_SIZE = 2
+
+  def display_tag(tag)
+    puts "#{TAG_PREFIX} #{tag}".red
+  end
+
+  def display_todo(todo, indent_level, highlighted: false)
+    # Add indentation based on tree depth
+    indent = ' ' * (indent_level * INDENT_SIZE)
+
+    prefix = case todo.status
+             when "done"
+               DONE_PREFIX.grey
+             when "todo"
+               TODO_PREFIX.default
+             end
+
+    text_colored = todo.status == "done" ? todo.text.grey : todo.text.default
+
+    line_number = "[#{todo.idx}]".cyan
+    indicator = highlighted ? " ✔".green : ""
+
+    puts indent + [prefix, text_colored, line_number + indicator].join(" ")
+  end
+end

data/lib/taf/version.rb

@@ -0,0 +1 @@
+TAF_VERSION = "1.0.0".freeze

data/lib/taf.rb

@@ -0,0 +1,8 @@
+require_relative 'taf/version'
+require_relative 'taf/ansi_colors'
+require_relative 'taf/taf_helper'
+require_relative 'taf/models/todo'
+require_relative 'taf/markdown_adapter'
+require_relative 'taf/terminal_presenter'
+require_relative 'taf/models/taf'
+require_relative 'taf/cli'

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: taf-cli
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jean Moniatte
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Travail À Faire (taf) is a lightweight command-line tool that helps you
+  manage your todos in a markdown file with support for tags and hierarchical organization.
+email:
+- jmoniatte@fastmail.com
+executables:
+- taf
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/taf
+- lib/taf.rb
+- lib/taf/ansi_colors.rb
+- lib/taf/cli.rb
+- lib/taf/markdown_adapter.rb
+- lib/taf/models/taf.rb
+- lib/taf/models/todo.rb
+- lib/taf/taf_helper.rb
+- lib/taf/terminal_presenter.rb
+- lib/taf/version.rb
+homepage: https://github.com/jmoniatte/taf
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jmoniatte/taf
+  source_code_uri: https://github.com/jmoniatte/taf
+  changelog_uri: https://github.com/jmoniatte/taf/blob/master/CHANGELOG.md
+post_install_message: |
+  Thanks for installing taf-cli!
+
+  Get started with:
+    taf --help
+
+  Your todos will be stored in ~/taf.md by default.
+
+  For more info: https://github.com/jmoniatte/taf
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.15
+signing_key:
+specification_version: 4
+summary: A simple CLI todo list manager
+test_files: []