tasku 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a32bab956724e7408c6163998e3723591bcd8b29d47468432cc38e21384e848c
+  data.tar.gz: fd6d15eb4ae3d48f5cf1b4ebfd696d636b2dc652ad9d3846467ae8870c542d56
+SHA512:
+  metadata.gz: ac4edabbe7421d15b8c69608be6af274f6f3a0865a78cb228e9a15360ca848b4637b1bc25045ea8a68e4b38ab3d1b48b7b3f1e36c4120d885ca287ba283b3959
+  data.tar.gz: 46b1d2c093d9779d87aa07eb96b4f5c1b2c256998789ff8b7adf49e4c8501708ebedf7fb278e3203a0b77a164bdda1e9cadb726bac11c1473ab2537aa38519db

data/exe/tasku

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "tasku"
+
+Tasku::CLI::App.start(ARGV)

data/lib/tasku/cli.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+module Tasku
+  module CLI
+    LOGO = <<~LOGO
+       _______        _          
+      |__   __|      | |         
+         | | __ _ ___| | ___   _ 
+         | |/ _` / __| |/ / | | |
+         | | (_| \\__ \\   <| |_| |
+         |_|\\__,_|___/_|\\_\\\\__,_|
+    LOGO
+
+    TAGLINE = "\u30BF\u30B9\u30AF\u30EA\u30B9\u30C8 \u2014 terminal task manager"
+
+    class App < Thor
+      def self.start(args = ARGV, **opts)
+        pastel = Pastel.new
+        $stdout.puts ""
+        $stdout.puts pastel.bright_cyan(LOGO)
+        $stdout.puts pastel.bright_cyan("  #{TAGLINE}")
+        $stdout.puts ""
+        super
+      end
+
+      class_option :db, type: :string, desc: "Path to SQLite database (default: ~/.tasku/tasks.db)", hide: true
+
+      desc "add", "Create a new task"
+      option :name,        type: :string,  desc: "Task name", required: false
+      option :description, type: :string,  desc: "Task description"
+      option :project,     type: :string,  desc: "Project name"
+      option :category,    type: :string,  desc: "Category"
+      option :start,       type: :string,  desc: "Start date (YYYY-MM-DD)"
+      option :due,         type: :string,  desc: "Due date (YYYY-MM-DD)"
+      option :model,       type: :string,  desc: "Model identifier"
+      option :priority,    type: :string,  desc: "Priority: none, low, medium, high, urgent"
+      option :status,      type: :string,  desc: "Status: backlog, todo, in_progress, done, cancelled, archived"
+      option :tags,        type: :string,  desc: "Comma-separated tags"
+      option :hours,       type: :numeric, desc: "Estimated hours"
+      option :interactive, type: :boolean, aliases: "-i", desc: "Interactive mode", default: false
+      def add
+        attrs = if options[:interactive] || options.values_at(:name, :description, :project, :category).all?(&:nil?)
+                  interactive_add
+                else
+                  option_add
+                end
+
+        task = Task.create(attrs)
+        terminal.render_added(task)
+      rescue Sequel::ValidationFailed => e
+        abort pastel.red("Validation error: #{e.message}")
+      end
+
+      desc "list", "List all tasks"
+      option :status,   type: :string,  desc: "Filter by status"
+      option :priority, type: :string,  desc: "Filter by priority"
+      option :project,  type: :string,  desc: "Filter by project"
+      option :category, type: :string,  desc: "Filter by category"
+      option :tags,     type: :string,  desc: "Filter by tag (comma-separated)"
+      option :overdue,  type: :boolean, desc: "Show only overdue tasks"
+      option :sort,     type: :string,  desc: "Sort by: name, priority, due, status, created"
+      option :order,    type: :string,  desc: "Order: asc, desc", default: "asc"
+      def list
+        dataset = Task.dataset
+
+        dataset = dataset.where(status: options[:status]) if options[:status]
+        dataset = dataset.where(priority: options[:priority]) if options[:priority]
+        dataset = dataset.where(project: options[:project]) if options[:project]
+        dataset = dataset.where(category: options[:category]) if options[:category]
+
+        if options[:tags]
+          tag_filter = options[:tags].split(",").map(&:strip)
+          tag_filter.each do |t|
+            dataset = dataset.where(Sequel.ilike(:tags, "%#{t}%"))
+          end
+        end
+
+        if options[:overdue]
+          today = Date.today
+          dataset = dataset.where { due_day < today }.exclude(status: %w[done cancelled])
+        end
+
+        sort_col = case options[:sort]
+                   when "name"     then :name
+                   when "priority" then Sequel.case(Task::VALID_PRIORITIES.each_with_index.to_h, 999, :priority)
+                   when "due"      then :due_day
+                   when "status"   then Sequel.case(Task::VALID_STATUSES.each_with_index.to_h, 999, :status)
+                   else :created_at
+                   end
+
+        order = options[:order] == "desc" ? Sequel.desc(sort_col) : Sequel.asc(sort_col)
+        dataset = dataset.order(order)
+
+        tasks = dataset.all
+        terminal.render_list(tasks)
+      end
+
+      desc "show ID", "Show task details"
+      def show(id)
+        task = find_task(id)
+        terminal.render_show(task)
+      end
+
+      desc "edit ID", "Edit a task"
+      option :name,        type: :string,  desc: "Task name"
+      option :description, type: :string,  desc: "Task description"
+      option :project,     type: :string,  desc: "Project name"
+      option :category,    type: :string,  desc: "Category"
+      option :start,       type: :string,  desc: "Start date (YYYY-MM-DD)"
+      option :due,         type: :string,  desc: "Due date (YYYY-MM-DD)"
+      option :model,       type: :string,  desc: "Model identifier"
+      option :priority,    type: :string,  desc: "Priority: none, low, medium, high, urgent"
+      option :status,      type: :string,  desc: "Status: backlog, todo, in_progress, done, cancelled, archived"
+      option :tags,        type: :string,  desc: "Comma-separated tags"
+      option :hours,       type: :numeric, desc: "Estimated hours"
+      option :clear,       type: :string,  desc: "Clear a field: description, start, due, model, tags, hours"
+      def edit(id)
+        task = find_task(id)
+
+        attrs = option_edit
+        if attrs.empty? && !options[:clear]
+          puts pastel.yellow("No changes specified. Use --help to see available options.")
+          return
+        end
+
+        if options[:clear]
+          clear_fields = options[:clear].split(",").map(&:strip)
+          clear_map = {
+            "description" => :description,
+            "start"       => :start_day,
+            "due"         => :due_day,
+            "model"       => :model_name,
+            "tags"        => :tags,
+            "hours"       => :estimated_hours
+          }
+          clear_fields.each do |f|
+            col = clear_map[f]
+            if col
+              attrs[col] = nil
+            else
+              puts pastel.yellow("Unknown field to clear: #{f}")
+            end
+          end
+        end
+
+        task.update(attrs)
+        terminal.render_updated(task)
+      rescue Sequel::ValidationFailed => e
+        abort pastel.red("Validation error: #{e.message}")
+      end
+
+      desc "done ID", "Mark a task as done"
+      def done(id)
+        task = find_task(id)
+        task.update(status: "done")
+        terminal.render_updated(task)
+      end
+
+      desc "delete ID", "Delete a task"
+      option :force, type: :boolean, aliases: "-f", desc: "Skip confirmation"
+      def delete(id)
+        task = find_task(id)
+
+        unless options[:force]
+          prompt = TTY::Prompt.new
+          confirmed = prompt.yes?(pastel.red("Delete task ##{id} (#{task.name})?"))
+          return unless confirmed
+        end
+
+        task.destroy
+        terminal.render_deleted(task)
+      end
+
+      desc "stats", "Show task statistics"
+      def stats
+        tasks = Task.dataset.all
+        terminal.render_stats(tasks) if tasks
+      end
+
+      desc "projects", "List all projects"
+      def projects
+        projects = Task.dataset.select(:project).where(Sequel.~(project: nil)).distinct.order(:project).map(:project)
+        if projects.empty?
+          puts pastel.yellow("  No projects found.")
+          return
+        end
+
+        puts ""
+        projects.each do |p|
+          count = Task.where(project: p).count
+          puts "  #{pastel.bold(p)} #{pastel.dim("(#{count} task(s))")}"
+        end
+        puts ""
+      end
+
+      desc "categories", "List all categories"
+      def categories
+        categories = Task.dataset.select(:category).where(Sequel.~(category: nil)).distinct.order(:category).map(:category)
+        if categories.empty?
+          puts pastel.yellow("  No categories found.")
+          return
+        end
+
+        puts ""
+        categories.each do |c|
+          count = Task.where(category: c).count
+          puts "  #{pastel.bold(c)} #{pastel.dim("(#{count} task(s))")}"
+        end
+        puts ""
+      end
+
+      desc "version", "Show version"
+      def version
+        puts "tasku #{Tasku::VERSION}"
+      end
+
+      no_commands do
+        def terminal
+          @terminal ||= Output::Terminal.new
+        end
+
+        def pastel
+          @pastel ||= Pastel.new
+        end
+
+        def find_task(id)
+          task = Task[id.to_i]
+          abort pastel.red("Task ##{id} not found.") unless task
+          task
+        end
+
+        def parse_date(str)
+          return if str.nil? || str.strip.empty?
+
+          Date.parse(str)
+        rescue Date::Error
+          abort pastel.red("Invalid date: '#{str}'. Use YYYY-MM-DD format.")
+        end
+
+        def interactive_add
+          prompt = TTY::Prompt.new
+
+          name = prompt.ask("Task name:", required: true) do |q|
+            q.modify :strip
+          end
+
+          description = prompt.ask("Description:", default: "")
+          description = nil if description&.empty?
+
+          project = prompt.ask("Project:", default: "")
+          project = nil if project&.empty?
+
+          category = prompt.ask("Category:", default: "")
+          category = nil if category&.empty?
+
+          priority = prompt.select("Priority?", %w[none low medium high urgent], default: 1)
+          status = prompt.select("Status?", %w[backlog todo in_progress], default: 2)
+
+          start_day = prompt.ask("Start date (YYYY-MM-DD, optional):", default: "")
+          start_day = nil if start_day&.empty?
+
+          due_day = prompt.ask("Due date (YYYY-MM-DD, optional):", default: "")
+          due_day = nil if due_day&.empty?
+
+          model_name = prompt.ask("Model:", default: "")
+          model_name = nil if model_name&.empty?
+
+          tags = prompt.ask("Tags (comma-separated):", default: "")
+          tags = nil if tags&.empty?
+
+          hours = prompt.ask("Estimated hours:", default: "") do |q|
+            q.convert(:float, "")
+          end
+          hours = nil if hours.is_a?(String) && hours.empty?
+
+          {
+            name: name,
+            description: (description unless description&.empty?),
+            project: (project unless project&.empty?),
+            category: (category unless category&.empty?),
+            start_day: parse_date(start_day),
+            due_day: parse_date(due_day),
+            model_name: (model_name unless model_name&.empty?),
+            priority: priority,
+            status: status,
+            tags: (tags unless tags&.empty?),
+            estimated_hours: hours
+          }.compact
+        end
+
+        def option_add
+          validate_priority!(options[:priority]) if options[:priority]
+          validate_status!(options[:status]) if options[:status]
+
+          {
+            name: (options[:name] or abort(pastel.red("Name is required. Use --name or -i for interactive mode."))),
+            description: options[:description],
+            project: options[:project],
+            category: options[:category],
+            start_day: parse_date(options[:start]),
+            due_day: parse_date(options[:due]),
+            model_name: options[:model],
+            priority: options[:priority] || "none",
+            status: options[:status] || "todo",
+            tags: options[:tags],
+            estimated_hours: options[:hours]
+          }.compact
+        end
+
+        def option_edit
+          validate_priority!(options[:priority]) if options[:priority]
+          validate_status!(options[:status]) if options[:status]
+
+          {
+            name: options[:name],
+            description: options[:description],
+            project: options[:project],
+            category: options[:category],
+            start_day: parse_date(options[:start]),
+            due_day: parse_date(options[:due]),
+            model_name: options[:model],
+            priority: options[:priority],
+            status: options[:status],
+            tags: options[:tags],
+            estimated_hours: options[:hours]
+          }.compact
+        end
+
+        def validate_priority!(value)
+          return if Task::VALID_PRIORITIES.include?(value)
+
+          abort pastel.red("Invalid priority '#{value}'. Valid: #{Task::VALID_PRIORITIES.join(', ')}")
+        end
+
+        def validate_status!(value)
+          return if Task::VALID_STATUSES.include?(value)
+
+          abort pastel.red("Invalid status '#{value}'. Valid: #{Task::VALID_STATUSES.join(', ')}")
+        end
+      end
+    end
+  end
+end

data/lib/tasku/database.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "fileutils"
+
+module Tasku
+  module Database
+    DB_DIR = File.join(Dir.home, ".tasku")
+    DB_PATH = File.join(DB_DIR, "tasks.db")
+
+    def self.connect
+      FileUtils.mkdir_p(DB_DIR)
+      @db = Sequel.sqlite(DB_PATH)
+      Sequel::Model.db = @db
+      migrate
+      @db
+    end
+
+    def self.db
+      @db || connect
+    end
+
+    def self.migrate
+      db.create_table? :tasks do
+        primary_key :id
+        String :name, null: false
+        File :description
+        String :project
+        String :category
+        Date :start_day
+        Date :due_day
+        String :model_name
+        String :priority, default: "none"
+        String :status, default: "todo"
+        String :tags
+        Float :estimated_hours
+        DateTime :created_at, default: Sequel::CURRENT_TIMESTAMP
+        DateTime :updated_at, default: Sequel::CURRENT_TIMESTAMP
+      end
+    end
+  end
+end

data/lib/tasku/output/terminal.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Tasku
+  module Output
+    class Terminal
+      PRIORITY_STYLES = {
+        "none"   => { color: :dim,    symbol: " " },
+        "low"    => { color: :cyan,   symbol: "↓" },
+        "medium" => { color: :yellow, symbol: "■" },
+        "high"   => { color: :red,    symbol: "▲" },
+        "urgent" => { color: :bright_magenta, symbol: "‼" }
+      }.freeze
+
+      STATUS_STYLES = {
+        "backlog"     => { color: :dim,    symbol: "○" },
+        "todo"        => { color: :blue,   symbol: "○" },
+        "in_progress" => { color: :yellow, symbol: "◉" },
+        "done"        => { color: :green,  symbol: "✓" },
+        "cancelled"   => { color: :red,    symbol: "✗" },
+        "archived"    => { color: :dim,    symbol: "⊘" }
+      }.freeze
+
+      COL_SEP = "  "
+
+      def initialize
+        @pastel = Pastel.new
+        @term_width = [terminal_width, 80].min
+      end
+
+      def render_list(tasks)
+        if tasks.empty?
+          puts @pastel.yellow("  No tasks found.")
+          return
+        end
+
+        rows = tasks.map { |t| build_columns(t) }
+        col_widths = compute_widths(rows)
+        total = col_widths.sum + (COL_SEP.length * (col_widths.length - 1))
+
+        puts ""
+        puts @pastel.dim("  #{"─" * total}")
+        rows.each do |cols|
+          line = cols.each_with_index.map { |c, i| c.to_s.ljust(col_widths[i]) }.join(COL_SEP)
+          puts "  #{line}"
+        end
+        puts @pastel.dim("  #{"─" * total}")
+        puts @pastel.dim("  #{tasks.length} task(s) found")
+      end
+
+      def render_show(task)
+        puts ""
+        puts @pastel.bold("  Task ##{task.id}")
+        puts @pastel.dim("  #{"─" * 60}")
+
+        fields = [
+          ["Name",       @pastel.bold(task.name)],
+          ["Description", task.description ? @pastel.dim(task.description) : @pastel.dim("—")],
+          ["Project",    task.project || @pastel.dim("—")],
+          ["Category",   task.category || @pastel.dim("—")],
+          ["Priority",   priority_tag(task.priority)],
+          ["Status",     status_tag(task.status)],
+          ["Start Day",  task.start_day ? task.start_day.to_s : @pastel.dim("—")],
+          ["Due Day",    due_cell(task)],
+          ["Model",      task.model_name || @pastel.dim("—")],
+          ["Tags",       task.tag_list.empty? ? @pastel.dim("—") : task.tag_list.join(", ")],
+          ["Est. Hours", task.estimated_hours ? task.estimated_hours.to_s : @pastel.dim("—")],
+          ["Created",    task.created_at&.strftime("%Y-%m-%d %H:%M") || @pastel.dim("—")],
+          ["Updated",    task.updated_at&.strftime("%Y-%m-%d %H:%M") || @pastel.dim("—")]
+        ]
+
+        max_label = fields.map { |l, _| l.length }.max
+        fields.each do |label, value|
+          puts "  #{@pastel.dim(label.ljust(max_label))}  #{value}"
+        end
+        puts ""
+      end
+
+      def render_added(task)
+        puts @pastel.green("  ✓ Task ##{task.id} created") + " — #{@pastel.bold(task.name)}"
+      end
+
+      def render_updated(task)
+        puts @pastel.green("  ✓ Task ##{task.id} updated") + " — #{@pastel.bold(task.name)}"
+      end
+
+      def render_deleted(task)
+        puts @pastel.red("  ✗ Task ##{task.id} deleted") + " — #{@pastel.bold(task.name)}"
+      end
+
+      def render_stats(tasks)
+        puts ""
+        puts @pastel.bold("  Task Statistics")
+        puts @pastel.dim("  #{"─" * 60}")
+
+        total = tasks.length
+        by_status = tasks.group_by(&:status).transform_values(&:length)
+        by_priority = tasks.group_by(&:priority).transform_values(&:length)
+        overdue = tasks.count(&:overdue?)
+        projects = tasks.map(&:project).compact.uniq.length
+
+        puts "  #{@pastel.dim("Total tasks:".ljust(20))} #{total}"
+        puts "  #{@pastel.dim("Overdue:".ljust(20))} #{overdue.positive? ? @pastel.red(overdue.to_s) : @pastel.green("0")}"
+        puts "  #{@pastel.dim("Projects:".ljust(20))} #{projects}"
+        puts ""
+
+        puts "  #{@pastel.dim("By Status:")}"
+        Tasku::Task::VALID_STATUSES.each do |s|
+          count = by_status[s] || 0
+          next if count.zero?
+
+          puts "    #{status_tag(s)} #{@pastel.send(STATUS_STYLES.dig(s, :color) || :dim, count.to_s.rjust(3))}"
+        end
+
+        puts ""
+        puts "  #{@pastel.dim("By Priority:")}"
+        Tasku::Task::VALID_PRIORITIES.each do |p|
+          count = by_priority[p] || 0
+          next if count.zero?
+
+          puts "    #{priority_tag(p)} #{@pastel.send(PRIORITY_STYLES.dig(p, :color) || :dim, count.to_s.rjust(3))}"
+        end
+        puts ""
+      end
+
+      private
+
+      def build_columns(task)
+        id_str = @pastel.dim(task.id.to_s.rjust(2))
+        name_str = @pastel.bold(task.name)
+        proj_str = task.project || @pastel.dim("—")
+        prio_str = priority_tag(task.priority)
+        stat_str = status_tag(task.status)
+        due_str = due_cell(task)
+        [id_str, name_str, proj_str, prio_str, stat_str, due_str]
+      end
+
+      def compute_widths(rows)
+        raw = rows.map { |cols| cols.map { |c| strip_ansi(c.to_s).length } }
+        maxes = raw.transpose.map(&:max)
+        sep_total = COL_SEP.length * (maxes.length - 1)
+        fixed_cols = maxes[0] + maxes[2] + maxes[3] + maxes[4] + maxes[5]
+        available_name = @term_width - fixed_cols - sep_total - 4
+        min_name = 20
+
+        if maxes[1] > available_name || maxes[1] < min_name
+          name_width = [available_name, min_name].max
+          rows.each_with_index do |cols, _ri|
+            raw_str = strip_ansi(cols[1].to_s)
+            if raw_str.length > name_width
+              cols[1] = "#{raw_str[0..name_width - 2]}#{@pastel.dim("…")}"
+            end
+          end
+          maxes[1] = name_width
+        end
+
+        maxes
+      end
+
+      def strip_ansi(str)
+        str.gsub(/\e\[[0-9;]*m/, "")
+      end
+
+      def terminal_width
+        IO.console&.winsize&.[](1) || 80
+      rescue
+        80
+      end
+
+      def priority_tag(priority)
+        style = PRIORITY_STYLES[priority] || PRIORITY_STYLES["none"]
+        @pastel.send(style[:color], "#{style[:symbol]} #{priority.capitalize}")
+      end
+
+      def status_tag(status)
+        style = STATUS_STYLES[status] || STATUS_STYLES["backlog"]
+        label = status.tr("_", " ").capitalize
+        @pastel.send(style[:color], "#{style[:symbol]} #{label}")
+      end
+
+      def due_cell(task)
+        return @pastel.dim("—") unless task.due_day
+
+        diff = (task.due_day - Date.today).to_i
+        day = task.due_day.strftime("%b %d")
+        if task.overdue?
+          @pastel.red("#{day} (#{diff.abs}d ago)")
+        elsif diff.zero?
+          @pastel.yellow("#{day} (today)")
+        elsif diff <= 7
+          @pastel.yellow("#{day} (+#{diff}d)")
+        else
+          @pastel.green(day)
+        end
+      end
+    end
+  end
+end

data/lib/tasku/task.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "database"
+
+module Tasku
+  class Task < Sequel::Model(:tasks)
+    plugin :timestamps, update_on_create: true
+
+    VALID_PRIORITIES = %w[none low medium high urgent].freeze
+    VALID_STATUSES = %w[backlog todo in_progress done cancelled archived].freeze
+
+    def validate
+      super
+      errors.add(:name, "cannot be empty") if name.nil? || name.strip.empty?
+      if priority && !VALID_PRIORITIES.include?(priority)
+        errors.add(:priority, "must be one of: #{VALID_PRIORITIES.join(', ')}")
+      end
+      if status && !VALID_STATUSES.include?(status)
+        errors.add(:status, "must be one of: #{VALID_STATUSES.join(', ')}")
+      end
+    end
+
+    def tag_list
+      (tags || "").split(",").map(&:strip).reject(&:empty?)
+    end
+
+    def overdue?
+      return false unless due_day
+      due_day < Date.today && !%w[done cancelled].include?(status)
+    end
+  end
+
+end

data/lib/tasku/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tasku
+  VERSION = "0.1.0"
+end

data/lib/tasku.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "thor"
+require "pastel"
+require "tty-prompt"
+
+require_relative "tasku/version"
+require_relative "tasku/database"
+Tasku::Database.connect
+require_relative "tasku/task"
+require_relative "tasku/output/terminal"
+require_relative "tasku/cli"

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: tasku
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Dringer
+bindir: exe
+cert_chain: []
+date: 2026-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Tasku is a terminal-based task manager with colour-coded priorities,
+  status tracking, SQLite persistence, and a beautiful CLI interface.
+executables:
+- tasku
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/tasku
+- lib/tasku.rb
+- lib/tasku/cli.rb
+- lib/tasku/database.rb
+- lib/tasku/output/terminal.rb
+- lib/tasku/task.rb
+- lib/tasku/version.rb
+homepage: https://github.com/tomdringer/tasku
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: タスクリスト — a beautiful terminal task manager
+test_files: []