tasku 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74f35cfb28f9ec9b5b7cc0ce5a0a62028d7162faa7ed1a8e9efedb4f63fa2638
-  data.tar.gz: a064d7fa64823a9f3362e9220b4bc69311f2c20f21e10e6ae85501ed5f5f92de
+  metadata.gz: cd2fbd40e27817e56591b3a6ff769c59b109de5e34f2a09b416e38008de1428f
+  data.tar.gz: 787ea03c2a16d886bf62869d8e5174f28e5be667822e113fc248b32135e175bd
 SHA512:
-  metadata.gz: 93955913ae30ae85a403b3e11977739d64eac51c1fbebfeb97f07b6beac7149bba991e7da74f067778838f7fdda455ebfe6d74f273cc83e5239daaedc697be48
-  data.tar.gz: 0033c68f813e016cb2891fb7ed63e29d736f14460f18617fe021dbeeace9dc46c08639fc25f8764c1ccd0961edea2ad151225677ca7fb561e7214531706e338d
+  metadata.gz: 3998485e4d8369986f96db7ab64330e1f9b19993c025288899920fb02f6c6670fd0e9980cfcd881a755c00118e5ea002a980b3ca543d094f15d750c8cb86fb46
+  data.tar.gz: 3c7a5a32c70554e2824ba41d7cc8197669c57ff63e339cc0e7c9a0b5b40606018ba181c6baea59bf4cf1de777740148660d3bd2dbcfe241cd4498aff78dd34f0

data/lib/tasku/cli.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require "fileutils"
+require "json"
+require "net/http"
+require "uri"
+
 module Tasku
   module CLI
     LOGO = <<~LOGO
@@ -20,7 +25,11 @@ module Tasku
         puts ""
         Tasku::Config::VALID_KEYS.each do |key, meta|
           current = Tasku::Config.get(key)
-          options_str = meta[:values].map { |v| v == current ? pastel.bold(pastel.green(v)) : pastel.dim(v) }.join(", ")
+          if meta[:range]
+            options_str = pastel.bold(pastel.green(current)) + pastel.dim("  (#{meta[:range].min}–#{meta[:range].max})")
+          else
+            options_str = meta[:values].map { |v| v == current ? pastel.bold(pastel.green(v)) : pastel.dim(v) }.join(", ")
+          end
           puts "  #{pastel.bold(key.ljust(20))} #{options_str}  #{pastel.dim("— #{meta[:description]}")}"
         end
         puts ""
@@ -31,10 +40,11 @@ module Tasku
         pastel = Pastel.new
         meta = Tasku::Config::VALID_KEYS[key]
         abort pastel.red("Unknown preference '#{key}'. Run `tasku config list` to see available keys.") unless meta
-        unless meta[:values].include?(value)
-          abort pastel.red("Invalid value '#{value}' for '#{key}'. Valid: #{meta[:values].join(', ')}")
+        begin
+          Tasku::Config.set(key, value)
+        rescue ArgumentError => e
+          abort pastel.red("  #{e.message}")
         end
-        Tasku::Config.set(key, value)
         puts pastel.green("  ✓ #{key} set to '#{value}'.")
       end
 
@@ -45,6 +55,224 @@ module Tasku
         abort pastel.red("Unknown preference '#{key}'. Run `tasku config list` to see available keys.") unless meta
         puts "  #{key}: #{pastel.bold(Tasku::Config.get(key))}"
       end
+
+      desc "open", "Open the config file in $EDITOR"
+      def open
+        path = Tasku::Config::CONFIG_PATH
+        FileUtils.mkdir_p(File.dirname(path))
+        # Seed file with all defaults so every key is visible for editing.
+        current = Tasku::Config.all
+        seeded = Tasku::Config::VALID_KEYS.transform_values { |meta| meta[:default] }.merge(current)
+        File.write(path, JSON.pretty_generate(seeded))
+        editor = ENV["EDITOR"] || ENV["VISUAL"] || "vi"
+        exec(editor, path)
+      end
+    end
+
+    class CloudApp < Thor
+      desc "login TOKEN", "Authenticate with Tasku Cloud using an API token"
+      option :url, type: :string, desc: "Tasku Cloud URL (default: #{Tasku::Config::CLOUD_URL_DEFAULT})"
+      def login(token)
+        pastel = Pastel.new
+        url = options[:url] || Tasku::Config.cloud_url
+
+        puts pastel.dim("  Verifying token with #{url}...")
+
+        begin
+          uri = URI.join(url, "/api/v1/sync")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+          http.open_timeout = 10
+          http.read_timeout = 10
+
+          req = Net::HTTP::Post.new(uri.path, {
+            "Content-Type"  => "application/json",
+            "Authorization" => "Bearer #{token}"
+          })
+          req.body = JSON.generate({ tasks: [], last_synced_at: nil })
+
+          res = http.request(req)
+        rescue Errno::ECONNREFUSED, Errno::ENOENT, SocketError, Net::OpenTimeout => e
+          abort pastel.red("  Could not connect to #{url}: #{e.message}")
+        end
+
+        if res.code == "200"
+          Tasku::Config.cloud_token = token
+          Tasku::Config.cloud_url = url if options[:url]
+          puts ""
+          puts pastel.green("  ✓ Logged in to Tasku Cloud.")
+          puts pastel.dim("  Token saved to ~/.tasku/config.json")
+          puts pastel.dim("  Run `tasku cloud sync` to sync your tasks.")
+          puts ""
+        elsif res.code == "401"
+          abort pastel.red("  Invalid token. Check it and try again.")
+        else
+          abort pastel.red("  Unexpected response from server (#{res.code}).")
+        end
+      end
+
+      desc "status", "Show Tasku Cloud connection status"
+      def status
+        pastel = Pastel.new
+        puts ""
+        if Tasku::Config.cloud_configured?
+          puts "  #{pastel.green("●")} Connected to #{pastel.bold(Tasku::Config.cloud_url)}"
+          last = Tasku::Config.last_synced_at
+          puts "  Last synced: #{last ? pastel.bold(last.localtime.strftime("%-d %b %Y at %H:%M")) : pastel.dim("never")}"
+        else
+          puts "  #{pastel.dim("○")} Not connected."
+          puts "  #{pastel.dim("Run `tasku cloud login <token>` to connect.")}"
+        end
+        puts ""
+      end
+
+      desc "logout", "Remove saved Tasku Cloud credentials"
+      def logout
+        pastel = Pastel.new
+        Tasku::Config.cloud_token = nil
+        Tasku::Config.last_synced_at = nil
+        puts pastel.green("  ✓ Logged out of Tasku Cloud.")
+      end
+
+      desc "sync", "Two-way sync tasks with Tasku Cloud"
+      def sync
+        pastel = Pastel.new
+
+        unless Tasku::Config.cloud_configured?
+          abort pastel.red("  Not connected. Run `tasku cloud login <token>` first.")
+        end
+
+        url            = Tasku::Config.cloud_url
+        token          = Tasku::Config.cloud_token
+        last_synced_at = Tasku::Config.last_synced_at
+
+        puts pastel.dim("  Syncing with #{url}...")
+
+        # Serialise every local task for upload
+        local_tasks = Tasku::Task.all.map do |t|
+          {
+            uuid:            t.uuid,
+            name:            t.name,
+            description:     t.description,
+            project:         t.project,
+            category:        t.category,
+            start_day:       t.start_day&.iso8601,
+            due_day:         t.due_day&.iso8601,
+            code:            t.code,
+            priority:        t.priority,
+            status:          t.status,
+            tags:            t.tags,
+            estimated_hours: t.estimated_hours,
+            updated_at:      t.updated_at&.utc&.iso8601,
+            created_at:      t.created_at&.utc&.iso8601
+          }
+        end
+
+        begin
+          uri  = URI.join(url, "/api/v1/sync")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl    = uri.scheme == "https"
+          http.open_timeout = 15
+          http.read_timeout = 30
+
+          req = Net::HTTP::Post.new(uri.path, {
+            "Content-Type"  => "application/json",
+            "Authorization" => "Bearer #{token}"
+          })
+          local_projects = Tasku::Database.db[:projects].all.map do |p|
+            { name: p[:name], colour: p[:colour] }
+          end
+
+          req.body = JSON.generate({ tasks: local_tasks, projects: local_projects, last_synced_at: last_synced_at&.iso8601 })
+
+          res = http.request(req)
+        rescue Errno::ECONNREFUSED, Errno::ENOENT, SocketError, Net::OpenTimeout => e
+          abort pastel.red("  Could not connect to #{url}: #{e.message}")
+        end
+
+        if res.code == "401"
+          abort pastel.red("  Invalid token — run `tasku cloud login <token>` to reauthenticate.")
+        elsif res.code != "200"
+          abort pastel.red("  Sync failed (HTTP #{res.code}).")
+        end
+
+        body         = JSON.parse(res.body)
+        server_tasks = body["tasks"] || []
+        synced_at    = body["synced_at"]
+
+        created = updated = conflicts = 0
+
+        server_tasks.each do |st|
+          next unless st["uuid"]
+
+          # Conflict tasks live server-side; the user resolves them on the web.
+          if st["conflict"]
+            conflicts += 1
+            next
+          end
+
+          local = Tasku::Task.first(uuid: st["uuid"])
+
+          server_updated = st["updated_at"] ? Time.parse(st["updated_at"]).utc : nil
+
+          if local.nil?
+            # New task from cloud — write directly to bypass timestamps plugin
+            # so updated_at matches the server's value exactly.
+            Tasku::Database.db[:tasks].insert(
+              uuid:            st["uuid"],
+              name:            st["name"],
+              description:     st["description"],
+              project:         st["project"],
+              category:        st["category"],
+              start_day:       st["start_day"] ? Date.parse(st["start_day"]) : nil,
+              due_day:         st["due_day"]   ? Date.parse(st["due_day"])   : nil,
+              code:            st["code"],
+              priority:        st["priority"] || "none",
+              status:          st["status"]   || "todo",
+              tags:            st["tags"],
+              estimated_hours: st["estimated_hours"],
+              created_at:      st["created_at"] ? Time.parse(st["created_at"]).utc : Time.now.utc,
+              updated_at:      server_updated || Time.now.utc
+            )
+            created += 1
+          else
+            local_updated = local.updated_at ? local.updated_at.utc : nil
+
+            if server_updated && local_updated && server_updated > local_updated
+              # Write via dataset to preserve server's updated_at exactly,
+              # preventing the local timestamp from drifting forward and
+              # triggering another upload next sync.
+              Tasku::Database.db[:tasks].where(id: local.id).update(
+                name:            st["name"],
+                description:     st["description"],
+                project:         st["project"],
+                category:        st["category"],
+                start_day:       st["start_day"] ? Date.parse(st["start_day"]) : nil,
+                due_day:         st["due_day"]   ? Date.parse(st["due_day"])   : nil,
+                code:            st["code"],
+                priority:        st["priority"] || "none",
+                status:          st["status"]   || "todo",
+                tags:            st["tags"],
+                estimated_hours: st["estimated_hours"],
+                updated_at:      server_updated
+              )
+              updated += 1
+            end
+          end
+        end
+
+        Tasku::Config.last_synced_at = synced_at ? Time.parse(synced_at).utc : Time.now.utc
+
+        puts ""
+        puts "  #{pastel.green("✓")} Sync complete."
+        puts "  #{pastel.bold(local_tasks.count.to_s)} #{local_tasks.count == 1 ? "task" : "tasks"} pushed to cloud."
+        puts "  #{pastel.bold(created.to_s)} #{created == 1 ? "task" : "tasks"} pulled from cloud."  if created > 0
+        puts "  #{pastel.bold(updated.to_s)} #{updated == 1 ? "task" : "tasks"} updated from cloud." if updated > 0
+        if conflicts > 0
+          puts "  #{pastel.yellow("⚠")}  #{conflicts} #{conflicts == 1 ? "conflict" : "conflicts"} — visit #{pastel.bold(url)} to resolve."
+        end
+        puts ""
+      end
     end
 
     class App < Thor
@@ -74,6 +302,9 @@ module Tasku
       desc "config SUBCOMMAND", "Manage user preferences"
       subcommand "config", ConfigApp
 
+      desc "cloud SUBCOMMAND", "Sync tasks with Tasku Cloud"
+      subcommand "cloud", CloudApp
+
       def help(*args)
         if args.empty?
           puts ""
@@ -161,6 +392,11 @@ module Tasku
                   option_add
                 end
 
+        if attrs.nil?
+          puts pastel.yellow("  Add cancelled.")
+          return
+        end
+
         task = Task.create(attrs)
         terminal.render_added(task)
       rescue Sequel::ValidationFailed => e
@@ -173,9 +409,11 @@ module Tasku
       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: id, name, priority, due, status, created"
-      option :order,    type: :string,  desc: "Order: asc, desc", default: "asc"
+      option :overdue,   type: :boolean, desc: "Show only overdue tasks"
+      option :today,     type: :boolean, desc: "Show tasks due today"
+      option :tomorrow,  type: :boolean, desc: "Show tasks due tomorrow"
+      option :sort,      type: :string,  desc: "Sort by: id, name, priority, due, status, created"
+      option :order,     type: :string,  desc: "Order: asc, desc", default: "asc"
       def list
         dataset = Task.dataset
 
@@ -196,6 +434,16 @@ module Tasku
           dataset = dataset.where { due_day < today }.exclude(status: %w[done cancelled])
         end
 
+        if options[:today]
+          today = Date.today
+          dataset = dataset.where(due_day: today).exclude(status: %w[done cancelled])
+        end
+
+        if options[:tomorrow]
+          tomorrow = Date.today + 1
+          dataset = dataset.where(due_day: tomorrow).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)
@@ -210,10 +458,21 @@ module Tasku
 
         tasks = dataset.all
         bar = { "bar_project" => Config.get("bar_project"), "bar_priority" => Config.get("bar_priority"), "bar_status" => Config.get("bar_status") }
+        cols_cfg = {
+          "col_project"      => Config.get("col_project"),
+          "col_category"     => Config.get("col_category"),
+          "col_priority"     => Config.get("col_priority"),
+          "col_status"       => Config.get("col_status"),
+          "col_due"          => Config.get("col_due"),
+          "col_name_min"     => Config.get("col_name_min"),
+          "col_priority_min" => Config.get("col_priority_min"),
+          "col_status_min"   => Config.get("col_status_min"),
+          "col_due_min"      => Config.get("col_due_min")
+        }
         if ENV["MADO"] == "1"
-          Tasku::TUI::MadoList.new(tasks, colour_map: Project.colour_map, bar: bar).run
+          Tasku::TUI::MadoList.new(tasks, colour_map: Project.colour_map, bar: bar, cols_cfg: cols_cfg, project: options[:project]).run
         else
-          terminal.render_list(tasks, colour_map: Project.colour_map, spacing: Config.get("list_spacing"), bar: bar)
+          terminal.render_list(tasks, colour_map: Project.colour_map, spacing: Config.get("list_spacing"), bar: bar, cols_cfg: cols_cfg)
         end
       end
 
@@ -237,10 +496,19 @@ module Tasku
       option :hours,       type: :numeric, desc: "Estimated hours"
       option :code,        type: :string,  desc: "Code"
       option :clear,       type: :string,  desc: "Clear a field: description, start, due, model, tags, hours, code"
+      option :interactive, type: :boolean, aliases: "-i", desc: "Interactive mode", default: false
       def edit(id)
         task = find_task(id)
 
-        attrs = option_edit
+        attrs = if options[:interactive]
+                  interactive_edit(task)
+                else
+                  option_edit
+                end
+        if attrs.nil?
+          puts pastel.yellow("  Edit cancelled.")
+          return
+        end
         if attrs.empty? && !options[:clear]
           puts pastel.yellow("No changes specified. Use --help to see available options.")
           return
@@ -296,8 +564,11 @@ module Tasku
       end
 
       desc "stats", "Show task statistics"
+      option :project, type: :string, desc: "Filter by project"
       def stats
-        tasks = Task.dataset.all
+        dataset = Task.dataset
+        dataset = dataset.where(project: options[:project]) if options[:project]
+        tasks = dataset.all
         terminal.render_stats(tasks, colour_map: Project.colour_map) if tasks
       end
 
@@ -437,6 +708,69 @@ module Tasku
             tags: (tags unless tags&.empty?),
             estimated_hours: hours
           }.compact
+        rescue TTY::Reader::InputInterrupt
+          nil
+        end
+
+        def interactive_edit(task)
+          prompt = TTY::Prompt.new
+
+          name = prompt.ask("Task name:", default: task.name, required: true) do |q|
+            q.modify :strip
+          end
+
+          description = prompt.ask("Description:", default: task.description || "")
+          description = nil if description&.empty?
+
+          project = prompt.ask("Project:", default: task.project || "")
+          project = nil if project&.empty?
+
+          category = prompt.ask("Category:", default: task.category || "")
+          category = nil if category&.empty?
+
+          priority = prompt.select("Priority?", %w[none low medium high urgent],
+                                   default: task.priority || "none")
+          status = prompt.select("Status?", Task::VALID_STATUSES,
+                                 default: task.status || "todo")
+
+          start_day = prompt.ask("Start date (YYYY-MM-DD, optional):",
+                                 default: task.start_day&.to_s || "")
+          start_day = nil if start_day&.empty?
+
+          due_day = prompt.ask("Due date (YYYY-MM-DD, optional):",
+                               default: task.due_day&.to_s || "")
+          due_day = nil if due_day&.empty?
+
+          model_name = prompt.ask("Model:", default: task.model_name || "")
+          model_name = nil if model_name&.empty?
+
+          code = prompt.ask("Code:", default: task.code || "")
+          code = nil if code&.empty?
+
+          tags = prompt.ask("Tags (comma-separated):", default: task.tags || "")
+          tags = nil if tags&.empty?
+
+          hours = prompt.ask("Estimated hours:", default: task.estimated_hours&.to_s || "") do |q|
+            q.convert(:float, "")
+          end
+          hours = nil if hours.is_a?(String) && hours.empty?
+
+          {
+            name: name,
+            description: description,
+            project: project,
+            category: category,
+            start_day: parse_date(start_day),
+            due_day: parse_date(due_day),
+            model_name: model_name,
+            code: code,
+            priority: priority,
+            status: status,
+            tags: tags,
+            estimated_hours: hours
+          }.compact
+        rescue TTY::Reader::InputInterrupt
+          nil
         end
 
         def option_add

data/lib/tasku/config.rb

@@ -27,14 +27,104 @@ module Tasku
         values: %w[on off],
         default: "on",
         description: "Show status colour segment in row bar"
+      },
+      "col_project" => {
+        values: %w[on off],
+        default: "off",
+        description: "Show project column in task list"
+      },
+      "col_priority" => {
+        values: %w[on off],
+        default: "on",
+        description: "Show priority column in task list"
+      },
+      "col_status" => {
+        values: %w[on off],
+        default: "on",
+        description: "Show status column in task list"
+      },
+      "col_due" => {
+        values: %w[on off],
+        default: "on",
+        description: "Show due date column in task list"
+      },
+      "col_name_min" => {
+        range: 10..200,
+        default: "20",
+        description: "Minimum width (chars) of the name column"
+      },
+      "col_priority_min" => {
+        range: 4..40,
+        default: "10",
+        description: "Minimum width (chars) of the priority column"
+      },
+      "col_status_min" => {
+        range: 4..40,
+        default: "11",
+        description: "Minimum width (chars) of the status column"
+      },
+      "col_due_min" => {
+        range: 4..40,
+        default: "19",
+        description: "Minimum width (chars) of the due date column"
       }
     }.freeze
 
+    # ── Cloud sync settings ────────────────────────────────────────────────
+    CLOUD_URL_DEFAULT = "https://tasku.cloud".freeze
+
+    def self.cloud_token
+      cloud["token"]
+    end
+
+    def self.cloud_token=(value)
+      save_cloud("token", value)
+    end
+
+    def self.cloud_url
+      cloud["url"] || CLOUD_URL_DEFAULT
+    end
+
+    def self.cloud_url=(value)
+      save_cloud("url", value)
+    end
+
+    def self.last_synced_at
+      raw = cloud["last_synced_at"]
+      raw ? Time.parse(raw).utc : nil
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def self.last_synced_at=(time)
+      save_cloud("last_synced_at", time&.utc&.iso8601)
+    end
+
+    def self.cloud_configured?
+      !cloud_token.nil?
+    end
+
     def self.get(key)
       all[key] || VALID_KEYS.dig(key, :default)
     end
 
+    def self.get_int(key)
+      get(key).to_i
+    end
+
     def self.set(key, value)
+      pastel = Pastel.new rescue nil
+      meta = VALID_KEYS[key]
+      raise ArgumentError, "Unknown key '#{key}'" unless meta
+
+      if meta[:range]
+        int = Integer(value) rescue nil
+        raise ArgumentError, "Value must be an integer between #{meta[:range].min} and #{meta[:range].max}" unless int && meta[:range].include?(int)
+        value = int.to_s
+      elsif meta[:values]
+        raise ArgumentError, "Invalid value '#{value}'. Valid: #{meta[:values].join(', ')}" unless meta[:values].include?(value)
+      end
+
       current = all
       current[key] = value
       FileUtils.mkdir_p(File.dirname(CONFIG_PATH))
@@ -48,5 +138,18 @@ module Tasku
     rescue JSON::ParserError
       {}
     end
+
+    def self.cloud
+      all["cloud"] || {}
+    end
+
+    def self.save_cloud(key, value)
+      current = all
+      current["cloud"] ||= {}
+      current["cloud"][key] = value
+      FileUtils.mkdir_p(File.dirname(CONFIG_PATH))
+      File.write(CONFIG_PATH, JSON.pretty_generate(current))
+    end
+    private_class_method :cloud, :save_cloud
   end
 end

data/lib/tasku/database.rb

@@ -2,6 +2,7 @@
 
 require "sequel"
 require "fileutils"
+require "securerandom"
 
 module Tasku
   module Database
@@ -10,6 +11,9 @@ module Tasku
 
     def self.connect
       FileUtils.mkdir_p(DB_DIR)
+      # Treat all stored datetime strings as UTC so comparisons with
+      # cloud timestamps (which are always UTC) stay consistent.
+      Sequel.database_timezone = :utc
       @db = Sequel.sqlite(DB_PATH)
       Sequel::Model.db = @db
       migrate
@@ -43,6 +47,14 @@ module Tasku
         db.alter_table(:tasks) { add_column :code, String }
       end
 
+      if db.table_exists?(:tasks) && !db.schema(:tasks).map(&:first).include?(:uuid)
+        db.alter_table(:tasks) { add_column :uuid, String }
+        # Backfill existing tasks with UUIDs
+        db[:tasks].where(uuid: nil).each do |row|
+          db[:tasks].where(id: row[:id]).update(uuid: SecureRandom.uuid)
+        end
+      end
+
       db.create_table? :projects do
         String :name, primary_key: true
         String :colour

data/lib/tasku/output/terminal.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pastel"
+require "io/console"
 
 module Tasku
   module Output
@@ -39,27 +40,30 @@ module Tasku
         "archived"    => { color: :dim,    symbol: "⊘" }
       }.freeze
 
-      COL_SEP = "  "
+      COL_SEP = " │ "
+      # Maximum visible width of a due_cell value:
+      # "Mmm DD (NNNd ago)" = 17 chars.
+      DUE_COL_MIN_WIDTH = 17
 
       def initialize
         @pastel = Pastel.new
         @term_width = terminal_width
       end
 
-      def render_list(tasks, colour_map: {}, spacing: "compact", bar: {})
+      def render_list(tasks, colour_map: {}, spacing: "compact", bar: {}, cols_cfg: {})
         if tasks.empty?
           puts @pastel.yellow("  No tasks found.")
           return
         end
 
-        rows = tasks.map { |t| build_columns(t, colour_map, bar) }
-        col_widths = compute_widths(rows)
+        rows = tasks.map { |t| build_columns(t, colour_map, bar, cols_cfg) }
+        col_widths = compute_widths(rows, cols_cfg)
         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)
+          line = cols.each_with_index.map { |c, i| ansi_ljust(c.to_s, col_widths[i]) }.join(COL_SEP)
           puts "  #{line}"
           puts "" if spacing == "spacious"
         end
@@ -154,26 +158,55 @@ module Tasku
       end
 
       # Returns an array of pre-formatted row strings for MadoList.
-      # Accounts for the "[>] " prefix (4 extra chars) when computing widths.
-      def build_mado_rows(tasks, colour_map = {}, bar = {})
-        return [] if tasks.empty?
+      # Accounts for the "  [>] " prefix (6 extra chars) when computing widths.
+      # Optional columns (project → priority → status, never due) are dropped
+      # until ≥15 chars are available for task names.  Names are only truncated
+      # if they still overflow after all optional columns have been tried.
+      def build_mado_rows(tasks, colour_map = {}, bar = {}, cols_cfg = {})
+        return { rows: [], row_width: 0 } if tasks.empty?
 
         orig_width  = @term_width
-        @term_width = [@term_width - 4, 40].max
+        @term_width = [orig_width - 6, 40].max
 
-        col_rows   = tasks.map { |t| build_columns(t, colour_map, bar) }
-        col_widths = compute_widths(col_rows)
-        result = col_rows.map do |cols|
-          cols.each_with_index.map { |c, i| ansi_ljust(c.to_s, col_widths[i]) }.join(COL_SEP)
+        cfg = cols_cfg.dup
+
+        # Drop optional columns (project → category → priority → status) until names have room.
+        %i[project category priority status].each do |drop_col|
+          probe = tasks.map { |t| build_columns(t, colour_map, bar, cfg) }
+          ws    = mado_max_col_widths(probe, cfg)
+          break if mado_name_available(ws) >= 15
+          next if cfg["col_#{drop_col}"] == "off"
+          cfg["col_#{drop_col}"] = "off"
+        end
+
+        col_rows   = tasks.map { |t| build_columns(t, colour_map, bar, cfg) }
+        col_widths = mado_max_col_widths(col_rows, cfg)
+        col_widths = mado_apply_truncation(col_rows, col_widths)
+
+        dim_sep = @pastel.dim(COL_SEP)
+        result  = col_rows.map do |cols|
+          cols.each_with_index.map { |c, i| ansi_ljust(c.to_s, col_widths[i]) }.join(dim_sep)
+        end
+
+        # Build header row aligned to col_widths.
+        labels = ["ID", "Name"]
+        %i[project category priority status due].each do |col|
+          next if cfg["col_#{col}"] == "off"
+          labels << { project: "Project", category: "Category",
+                      priority: "Priority", status: "Status", due: "Due" }[col]
         end
+        header = labels.each_with_index
+                       .map { |lbl, i| ansi_ljust(@pastel.dim(lbl), col_widths[i]) }
+                       .join(dim_sep)
 
+        row_width = col_widths.sum + COL_SEP.length * (col_widths.length - 1)
         @term_width = orig_width
-        result
+        { rows: result, row_width: row_width, header: header }
       end
 
       private
 
-      def build_columns(task, colour_map = {}, bar = {})
+      def build_columns(task, colour_map = {}, bar = {}, cols_cfg = {})
         id_val = task.code && !task.code.empty? ? "#{task.code}-#{task.id}" : task.id.to_s
 
         segments = []
@@ -193,36 +226,120 @@ module Tasku
                  else
                    @pastel.dim(id_val)
                  end
-        name_str = @pastel.bold(task.name)
-        proj_str = project_str(task.project, colour_map)
-        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]
+
+        # ID (col 0) and Name (col 1) are always present.
+        result = [id_str, @pastel.bold(task.name)]
+        result << project_str(task.project, colour_map) unless cols_cfg["col_project"]  == "off"
+        result << category_str(task.category)           unless cols_cfg["col_category"] == "off"
+        result << priority_tag(task.priority)           unless cols_cfg["col_priority"] == "off"
+        result << status_tag(task.status)               unless cols_cfg["col_status"]   == "off"
+        result << due_cell(task)                        unless cols_cfg["col_due"]       == "off"
+        result
       end
 
-      def compute_widths(rows)
+      def compute_widths(rows, cols_cfg = {})
         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|
+        # Track which array index each optional column landed at (after id=0, name=1).
+        col_idx = {}
+        i = 2
+        %i[project category priority status due].each do |col|
+          unless cols_cfg["col_#{col}"] == "off"
+            col_idx[col] = i
+            i += 1
+          end
+        end
+
+        # Apply user-configured minimum widths for optional fixed columns.
+        {
+          priority: [cols_cfg["col_priority_min"].to_i, 4].max,
+          status:   [cols_cfg["col_status_min"].to_i,   4].max,
+          due:      [[cols_cfg["col_due_min"].to_i, DUE_COL_MIN_WIDTH].max]
+        }.each do |col, mins|
+          if (idx = col_idx[col])
+            maxes[idx] = ([maxes[idx]] + Array(mins)).max
+          end
+        end
+
+        sep_total = COL_SEP.length * (maxes.length - 1)
+        # Fixed cols = everything except the name column (always at index 1).
+        fixed_cols = maxes.each_with_index.sum { |m, i| i == 1 ? 0 : m }
+        available_name = @term_width - fixed_cols - sep_total - 6
+
+        # Truncate names that would overflow; use count-based slice to avoid
+        # Ruby's negative-index wrapping when name_width is 0 or 1.
+        name_width = [available_name, 0].max
+        if maxes[1] > name_width
+          rows.each do |cols|
             raw_str = strip_ansi(cols[1].to_s)
             if raw_str.length > name_width
-              cols[1] = "#{raw_str[0..name_width - 2]}#{@pastel.dim("…")}"
+              keep = [name_width - 1, 0].max
+              cols[1] = keep > 0 ? "#{raw_str[0, keep]}#{@pastel.dim("…")}" : ""
             end
           end
-          maxes[1] = name_width
+        else
+          name_width = maxes[1]
+        end
+        maxes[1] = name_width
+
+        maxes
+      end
+
+      # Returns per-column max widths, applying configured minimums for
+      # priority (≥4), status (≥4), and due (≥DUE_COL_MIN_WIDTH).
+      # @term_width must already be reduced by 6 (the MadoList prefix).
+      def mado_max_col_widths(rows, cols_cfg = {})
+        raw   = rows.map { |cols| cols.map { |c| strip_ansi(c.to_s).length } }
+        maxes = raw.transpose.map(&:max)
+
+        col_idx = {}
+        i = 2
+        %i[project category priority status due].each do |col|
+          next if cols_cfg["col_#{col}"] == "off"
+          col_idx[col] = i
+          i += 1
+        end
+
+        { priority: [cols_cfg["col_priority_min"].to_i, 4].max,
+          status:   [cols_cfg["col_status_min"].to_i,   4].max,
+          due:      [cols_cfg["col_due_min"].to_i, DUE_COL_MIN_WIDTH].max
+        }.each do |col, min|
+          maxes[col_idx[col]] = [maxes[col_idx[col]], min].max if col_idx[col]
         end
 
         maxes
       end
 
+      # How many chars are available for the name column given a widths array.
+      def mado_name_available(maxes)
+        sep_total  = COL_SEP.length * (maxes.length - 1)
+        fixed_cols = maxes.each_with_index.sum { |m, i| i == 1 ? 0 : m }
+        @term_width - fixed_cols - sep_total
+      end
+
+      # Truncate name cells in-place if they exceed available space.
+      # Always expands the name column to fill available space so the table
+      # spans the full terminal width (short names are padded by ansi_ljust).
+      # Returns the (possibly updated) widths array.
+      def mado_apply_truncation(rows, maxes)
+        avail  = mado_name_available(maxes)
+        name_w = [avail, 0].max
+        if maxes[1] > name_w
+          rows.each do |cols|
+            s = strip_ansi(cols[1].to_s)
+            if s.length > name_w
+              keep    = [name_w - 1, 0].max
+              cols[1] = keep > 0 ? "#{s[0, keep]}#{@pastel.dim("…")}" : ""
+            end
+          end
+        end
+        # Always set name column to full available width so the table fills
+        # the terminal — short names will be space-padded by ansi_ljust.
+        maxes[1] = name_w
+        maxes
+      end
+
       def strip_ansi(str)
         str.gsub(/\e\[[0-9;]*m/, "")
       end
@@ -236,6 +353,13 @@ module Tasku
       end
 
       def terminal_width
+        # Mado writes the exact PTY column count to this file before running
+        # tasku list, bypassing unreliable ioctl/winsize methods inside the PTY.
+        cols_file = ENV["TASKU_COLS_FILE"] || "/tmp/tasku_mado_cols"
+        cols = File.read(cols_file).strip.to_i rescue 0
+        return cols if cols > 0
+
+        `stty size 2>/dev/null`.split.last.to_i.tap { |w| return w if w > 0 }
         IO.console&.winsize&.[](1) || 80
       rescue
         80
@@ -257,6 +381,10 @@ module Tasku
         "\e[38;2;#{r};#{g};#{b}m#{text}\e[0m"
       end
 
+      def category_str(category)
+        category && !category.empty? ? @pastel.cyan(category) : @pastel.dim("—")
+      end
+
       def project_str(project, colour_map)
         return @pastel.dim("—") unless project
 
@@ -274,6 +402,9 @@ module Tasku
         day = task.due_day.strftime("%b %d")
         if task.overdue?
           @pastel.red("#{day} (#{diff.abs}d ago)")
+        elsif diff < 0
+          # Past due but task is done/cancelled — show dimly, no alarm
+          @pastel.dim("#{day} (#{diff.abs}d ago)")
         elsif diff.zero?
           @pastel.yellow("#{day} (today)")
         elsif diff <= 7

data/lib/tasku/task.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "database"
+require "securerandom"
 
 module Tasku
   class Task < Sequel::Model(:tasks)
@@ -9,6 +10,11 @@ module Tasku
     VALID_PRIORITIES = %w[none low medium high urgent].freeze
     VALID_STATUSES = %w[backlog todo in_progress done cancelled archived].freeze
 
+    def before_create
+      super
+      self.uuid ||= SecureRandom.uuid
+    end
+
     def before_validation
       super
       self.code = code.to_s.upcase[0, 3] if code

data/lib/tasku/tui/mado_list.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "io/console"
+require "shellwords"
 require "pastel"
+require_relative "mado_log"
 
 module Tasku
   module TUI
@@ -10,37 +12,45 @@ module Tasku
     # selected task's ID is written to ENV["TASKU_SEL_FILE"] so that Mado
     # button handlers can inject it into commands like `tasku edit <id>`.
     class MadoList
-      HINT = "  ↑↓ navigate   a add   e/↵ edit   d delete   q quit"
+      HINT = "  ↑↓ navigate   a add   e/↵ edit   d delete   s stats   q quit"
 
-      def initialize(tasks, colour_map: {}, bar: {})
-        @tasks    = tasks
-        @cursor   = 0
-        @pastel   = Pastel.new
-        @sel_file = ENV["TASKU_SEL_FILE"]
-        @running  = true
+      def initialize(tasks, colour_map: {}, bar: {}, cols_cfg: {}, project: nil)
+        @tasks      = tasks
+        @cursor     = 0
+        @pastel     = Pastel.new
+        @sel_file   = ENV["TASKU_SEL_FILE"]
+        @running    = true
+        @inline_cmd = nil
+        @list_cmd   = project ? "tasku list --project #{Shellwords.shellescape(project)}" : "tasku list"
 
         # Pre-render row content once so key-press redraws are cheap.
-        @rows = Output::Terminal.new.build_mado_rows(tasks, colour_map, bar)
+        table      = Output::Terminal.new.build_mado_rows(tasks, colour_map, bar, cols_cfg)
+        @rows      = table[:rows]
+        @row_width = table[:row_width]
+        @header    = table[:header]
+
+        MadoLog.log("init tasks=#{tasks.length} cols_file=#{ENV["TASKU_COLS_FILE"]&.then { |f| File.read(f).strip rescue "?" }}")
       end
 
       def run
-        return if @tasks.empty?
-
-        write_selection
+        MadoLog.log("run tasks=#{@tasks.length}")
+        write_selection unless @tasks.empty?
 
         $stdout.print "\e[?25l"  # hide cursor
         at_exit { restore_terminal }
-        trap("INT") { @running = false }
+        trap("INT") { MadoLog.log("SIGINT received"); @running = false }
 
         $stdin.raw do |io|
           full_render
           while @running
             prev = @cursor
             key  = read_key(io)
+            MadoLog.log("key=#{key.inspect} cursor=#{@cursor} tasks=#{@tasks.length}") unless key.nil?
             handle_key(key)
             full_render if @running && @cursor != prev
           end
         end
+        MadoLog.log("run exited normally")
       end
 
       private
@@ -54,18 +64,50 @@ module Tasku
 
       # Full clear + repaint (initial draw or after a command).
       def full_render
-        $stdout.print "\e[H\e[J"  # cursor home, clear to end of screen
+        $stdout.print "\e[3J\e[H\e[2J"
+        if @tasks.empty?
+          $stdout.print "\r\n  #{@pastel.dim("No tasks found.")}\r\n"
+          $stdout.print "\r\n#{@pastel.dim("  Press any key to return to list…")}\r\n"
+          $stdout.flush
+          return
+        end
+        border = @pastel.dim("  " + "─" * (@row_width + 4))
+        $stdout.print "#{border}\r\n"
+        $stdout.print "  #{@pastel.dim("   ")} #{@header}\r\n" if @header
+        $stdout.print "#{border}\r\n"
         @rows.each_with_index do |row, i|
-          marker = i == @cursor ? @pastel.bright_blue("[>]") : @pastel.dim("[ ]")
-          $stdout.print "  #{marker} #{row}\r\n"
+          if i == @cursor
+            marker  = @pastel.bright_blue("[>]")
+            # Re-apply the highlight background after every ANSI reset so it
+            # persists through pre-rendered colour codes embedded in the row.
+            content = "  #{marker} #{row}".gsub("\e[0m", "\e[0m\e[48;5;236m")
+            $stdout.print "\e[48;5;236m#{content}\e[48;5;236m\e[K\e[0m\r\n"
+          else
+            marker = @pastel.dim("[ ]")
+            $stdout.print "  #{marker} #{row}\r\n"
+          end
         end
+        $stdout.print "#{border}\r\n"
+        $stdout.print "#{@pastel.dim("  #{@tasks.length} task(s) found")}\r\n"
         $stdout.print "\r\n#{@pastel.dim(HINT)}\r\n"
         $stdout.flush
       end
 
-def read_key(io)
+      def read_key(io)
         byte = io.getbyte
         case byte
+        when 0x02 # STX — inline exec protocol from Mado buttons.
+                  # Read the command string until newline; store it and
+                  # return :inline_exec so handle_key can exec it directly
+                  # without relying on the shell to pick up buffered input.
+          cmd = "".b
+          loop do
+            b = io.getbyte
+            break if b.nil? || b == 0x0A
+            cmd << b
+          end
+          @inline_cmd = cmd.force_encoding("UTF-8").scrub
+          :inline_exec
         when 0x1B
           second = io.getbyte
           if second == 0x5B
@@ -83,11 +125,21 @@ def read_key(io)
         when 0x64       then :delete   # d
         when 0x65       then :edit     # e
         when 0x71       then :q        # q
+        when 0x73       then :stats    # s
         else nil
         end
       end
 
       def handle_key(key)
+        if @tasks.empty?
+          case key
+          when :ctrl_c, :escape
+            @running = false
+          else
+            run_command("true")  # any other key → exec tasku list
+          end
+          return
+        end
         case key
         when :up
           @cursor = [@cursor - 1, 0].max
@@ -105,16 +157,65 @@ def read_key(io)
         when :delete
           return if @tasks.empty?
           run_command("tasku delete #{@tasks[@cursor].id} -f")
+        when :stats
+          run_and_show("tasku stats")
+        when :inline_exec
+          cmd = @inline_cmd.to_s
+          MadoLog.log("inline_exec cmd=#{cmd.inspect}")
+          if cmd == "SQL"
+            run_sql
+          else
+            run_command(cmd)
+          end
         end
       end
 
       # Restore the terminal, run a tasku command interactively, then re-exec
       # `tasku list` so the MadoList restarts fresh with updated data.
       def run_command(cmd)
+        MadoLog.log("run_command cmd=#{cmd.inspect}")
         @running = false
         restore_terminal
+        $stdin.cooked!
         system(cmd)
-        exec("tasku list")
+        MadoLog.log("run_command finished cmd=#{cmd.inspect} → exec #{@list_cmd}")
+        exec(@list_cmd)
+      end
+
+      # Run a non-interactive display command, wait for any keypress via
+      # getch (works in cooked mode — no raw-mode setup needed), then
+      # re-exec `tasku list`.
+      def run_and_show(cmd)
+        MadoLog.log("run_and_show cmd=#{cmd.inspect}")
+        @running = false
+        restore_terminal
+        $stdin.cooked!
+        system(cmd)
+        $stdout.print "\r\n\e[2m  Press any key to return to list…\e[0m\r\n"
+        $stdout.flush
+        $stdin.getch
+        MadoLog.log("run_and_show keypress received → exec #{@list_cmd}")
+        exec(@list_cmd)
+      end
+
+      # Show a SQL prompt, run the query, wait for keypress, then re-exec list.
+      def run_sql
+        MadoLog.log("run_sql")
+        @running = false
+        restore_terminal
+        $stdin.cooked!
+        $stdout.print "\r\n\e[36m  SELECT * FROM tasks WHERE status = 'todo'\e[0m\r\n\r\n"
+        $stdout.print "\e[2m  SQL> \e[0m"
+        $stdout.flush
+        q = $stdin.gets&.chomp
+        if q && !q.empty?
+          system("tasku", "sql", q)
+          $stdout.print "\r\n\e[2m  Press any key to return to list…\e[0m\r\n"
+          $stdout.flush
+          $stdin.getch
+        end
+        MadoLog.log("run_sql done → exec #{@list_cmd}")
+        exec(@list_cmd)
       end
 
       def restore_terminal

data/lib/tasku/tui/mado_log.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tasku
+  module TUI
+    # Minimal append-only logger shared with the Mado Rust process.
+    # Both sides write to /tmp/tasku_mado.log so button presses and
+    # MadoList state transitions can be correlated in one place.
+    module MadoLog
+      LOG_FILE = "/tmp/tasku_mado.log"
+
+      def self.log(msg)
+        File.open(LOG_FILE, "a") { |f| f.puts "[#{Time.now.to_i}] tasku: #{msg}" }
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/tasku/version.rb

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

data/lib/tasku.rb

@@ -17,6 +17,12 @@ begin
 rescue LoadError
   # TUI not available in this build
 end
+
+# Mado integration — ensure Tasku::TUI exists even if the full TUI did not load
+module Tasku
+  module TUI; end
+end
+require_relative "tasku/tui/mado_log"
 begin
   require_relative "tasku/tui/mado_list"
 rescue LoadError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tasku
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Tom Dringer
@@ -95,6 +95,7 @@ files:
 - lib/tasku/project.rb
 - lib/tasku/task.rb
 - lib/tasku/tui/mado_list.rb
+- lib/tasku/tui/mado_log.rb
 - lib/tasku/version.rb
 homepage: https://github.com/tomdringer/tasku
 licenses: