tasku 0.3.9 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74f35cfb28f9ec9b5b7cc0ce5a0a62028d7162faa7ed1a8e9efedb4f63fa2638
-  data.tar.gz: a064d7fa64823a9f3362e9220b4bc69311f2c20f21e10e6ae85501ed5f5f92de
+  metadata.gz: 206dc71e9498feb028e4c8b05fc3de8a23d6073b1da9db0988ef0acea3fc5f5d
+  data.tar.gz: 58dacb2562825ff61794649652c617b3ea7a4a619804a32c56067ff5ef2fd1ef
 SHA512:
-  metadata.gz: 93955913ae30ae85a403b3e11977739d64eac51c1fbebfeb97f07b6beac7149bba991e7da74f067778838f7fdda455ebfe6d74f273cc83e5239daaedc697be48
-  data.tar.gz: 0033c68f813e016cb2891fb7ed63e29d736f14460f18617fe021dbeeace9dc46c08639fc25f8764c1ccd0961edea2ad151225677ca7fb561e7214531706e338d
+  metadata.gz: 719c9a295c5868d5dbeb152e35cacde49d5be9f2ad229e2818a20d3eeaecf6ae86c461ea27e2d921c5b15ecbb48f0180f3e4c4ddc56d020dd36baaf5d901fb3e
+  data.tar.gz: 3c09b8f6970813d4a73d0772c2a92530d9e5958ad22f9fdd52c77a4f6fdc0a1b132af902ee59ba75060b25227695b48f7b22cf30541990cc763a4de41d5216c0

data/CHANGELOG.md

@@ -0,0 +1,97 @@
+# Changelog
+
+All notable changes to Tasku are documented here.
+
+## [0.4.1] - 2026-09-29
+
+### Fixed
+- **Cloud sync: project colours now sync down** — `tasku cloud sync` applied only the tasks from the server's response and ignored its `projects`, so colours set on another machine never arrived. They are now created or updated locally, and the sync summary reports how many changed. In Mado this also restores project colours and workspaces on a freshly synced machine
+
+## [0.4.0] - 2026-09-23
+
+### Added
+- **Tasku Cloud sync** — two-way sync with `tasku cloud sync`; authenticate with `tasku cloud login <token>`, check status with `tasku cloud status`, and revoke with `tasku cloud logout`
+- **`tasku config open`** — opens the config file in `$EDITOR` pre-seeded with all available keys and their defaults
+- **Numeric range preferences** — config keys that accept a numeric range (e.g. column minimum widths) now show their valid range in `tasku config list`
+- **`--code` flag** on `add` and `edit` — attach a short code to a task (e.g. `MDO-42`)
+- **`tasku sql`** — run a raw SQL `SELECT` query against the local database
+- **Category filtering** — `tasku list --category` and category column in list output
+- **Column visibility preferences** — `col_project`, `col_category`, `col_priority`, `col_status`, `col_due` can each be toggled `on`/`off` via `tasku config set`
+- **Column minimum width preferences** — `col_name_min`, `col_priority_min`, `col_status_min`, `col_due_min` for fine-tuning layout
+- **`tasku config open`** — open the config JSON in `$EDITOR` (pre-seeded with defaults)
+- **UUID field** on tasks for stable cross-device identity during cloud sync
+
+### Fixed
+- **Mado: status filter preserved after add/edit/delete** — `MadoList` now receives the full `list_cmd` (including `--status`, `--today`, `--overdue`, etc.) and passes it to `exec` on return, so the active view is restored correctly after an interactive command
+- **Mado: project filter preserved after add/edit/delete** — the inline-exec protocol (`\x02`) now replaces the MadoList process via `exec` instead of nesting it in a `system()` call, so the new MadoList inherits the correct `@list_cmd` and filter is preserved when navigating back from an interactive command
+- **Mado: project filter lost on workspace switch** — the open-panel flag is now tracked correctly for sidebar-positioned Tasku (not just the top-bar overlay), so switching workspace reliably refreshes the task list with the new project filter
+- **Mado: terminal left in raw mode after inline exec** — `$stdin.cooked!` is now called before `exec` when handling a `\x02tasku list` command, preventing the shell from inheriting raw-mode terminal attributes
+- **Due date column truncation** — `DUE_COL_MIN_WIDTH` raised to 17 to accommodate the longest possible due cell (`"Mmm DD (NNNd ago)"`)
+- **MadoList row overflow** — row prefix accounting corrected to 6 characters (`"  [>] "`), matching the actual rendered prefix; was previously 4, causing rows to exceed terminal width and wrap
+- **Name truncation** — task names that exceed available space are now truncated with `…`; names that fit are never truncated, fixing cases where the due-date column wrapped to the next line
+- **Column auto-drop on narrow terminals** — optional columns (project → category → priority → status) are dropped one at a time until at least 15 characters are available for task names, rather than wrapping or clipping
+
+### Changed
+- `tasku list` output uses a consistent `│`-separated column layout with a header row
+- `tasku config set` validates values via `ArgumentError` rather than a plain string comparison, supporting range constraints
+- `tasku stats` includes a "By Project" section sorted by task count
+- Sort defaults to `id` (ascending) when no `--sort` flag is given
+- `id` added as an explicit `--sort` option
+
+---
+
+## [0.3.9] - 2026-09-04
+
+### Added
+- **Mado TUI list mode** — `tasku list` launches an interactive cursor-driven list when `MADO=1` is set in the environment, designed for embedding in the Mado terminal multiplexer sidebar
+- Arrow-key navigation, selected task ID written to `TASKU_SEL_FILE` for Mado button integration
+- Inline-exec protocol (`\x02`) for receiving filter and display commands from Mado without shell round-trips
+- `build_mado_rows` and `ansi_ljust` helpers exposed on `Output::Terminal` for Mado's renderer
+
+---
+
+## [0.3.1] - 2026-08-29
+
+### Fixed
+- Terminal width was capped at 80 columns regardless of actual PTY size, severely truncating the name column in wider terminals — now uses the real terminal width
+
+### Changed
+- `tasku list` sorts by `id` by default
+- `exit_on_failure?` enabled on the CLI so bad subcommands exit with a non-zero status
+
+---
+
+## [0.3.0] - 2026-07-24
+
+### Added
+- **Project colours** — `tasku colour PROJECT #HEX` stores a hex colour per project; project names are tinted throughout `list`, `show`, and `stats`
+- **Colour bar** — three-segment bar in `tasku list` showing project, priority, and status at a glance (toggle each segment with `tasku config set bar_project on/off` etc.)
+- **User preferences** — `tasku config list` / `tasku config set KEY VALUE` / `tasku config get KEY`, backed by `~/.tasku/config.json`
+- `list_spacing` preference (`compact` / `spacious`)
+- **"By Project" section** in `tasku stats` sorted by task count
+- Logo restored on `tasku help` and bare `tasku` invocation
+
+---
+
+## [0.2.0] - 2026-07-01
+
+### Added
+- `tasku projects` — list all projects with task counts and colour swatches
+- `tasku categories` — list all categories
+- `tasku done ID` — shorthand to mark a task done
+- `--overdue`, `--today`, `--tomorrow` filter flags on `tasku list`
+- `--sort` and `--order` flags on `tasku list`
+- `--priority`, `--status`, `--tags` filter flags on `tasku list`
+- `--force` / `-f` flag on `tasku delete` to skip confirmation
+
+---
+
+## [0.1.0] - 2026-06-29
+
+Initial release.
+
+- `tasku add`, `tasku list`, `tasku show`, `tasku edit`, `tasku delete`
+- SQLite-backed storage at `~/.tasku/tasks.db`
+- Task fields: name, description, project, category, priority, status, start date, due date, tags, estimated hours
+- `tasku stats` — task breakdown by priority and status
+- Interactive add/edit with `-i` flag (TTY::Prompt)

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,240 @@ 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
+
+        # Local projects were pushed above, so the server's list already reflects
+        # them — adopt it wholesale so colours set on other machines come down.
+        projects_pulled = 0
+        (body["projects"] || []).each do |sp|
+          name   = sp["name"].to_s.strip
+          colour = sp["colour"].to_s.strip
+          next if name.empty? || colour !~ /\A#[0-9A-Fa-f]{6}\z/
+
+          proj = Tasku::Project.find_or_create(name: name)
+          next if proj.colour == colour
+
+          proj.update(colour: colour)
+          projects_pulled += 1
+        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
+        puts "  #{pastel.bold(projects_pulled.to_s)} #{projects_pulled == 1 ? "project colour" : "project colours"} updated from cloud." if projects_pulled > 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 +318,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 +408,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 +425,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 +450,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 +474,29 @@ 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
+          list_cmd = "tasku list"
+          list_cmd += " --status #{Shellwords.shellescape(options[:status])}"     if options[:status]
+          list_cmd += " --priority #{Shellwords.shellescape(options[:priority])}" if options[:priority]
+          list_cmd += " --project #{Shellwords.shellescape(options[:project])}"   if options[:project]
+          list_cmd += " --category #{Shellwords.shellescape(options[:category])}" if options[:category]
+          list_cmd += " --today"    if options[:today]
+          list_cmd += " --tomorrow" if options[:tomorrow]
+          list_cmd += " --overdue"  if options[:overdue]
+          Tasku::TUI::MadoList.new(tasks, colour_map: Project.colour_map, bar: bar, cols_cfg: cols_cfg, project: options[:project], list_cmd: list_cmd).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 +520,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 +588,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 +732,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