Merge feature/task-priority-#64: task priority P1-P4 (v2.10.5)

Author: manucompiles

CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ---
 
+## v2.10.5 - Task priority (P1-P4)
+*May 2026*
+
+### Added
+
+- Tasks now have a priority on the Todoist P1-P4 scale: P1 = Urgent (red), P2 = High (orange), P3 = Medium (blue), P4 = None (the default). Stored as a new `Priority` column (DB migration; existing tasks default to P4) (#64)
+- Set priority on the add-task form and the edit modal; a small colored dot appears next to the title for P1-P3 (P4 shows nothing). A priority filter row on the filter panel narrows the list by one or more priorities
+- MCP: `create_task` and `update_task` accept a `priority` param (1-4), `list_tasks` accepts a `priorities` filter, and the priority is included in returned task objects - so Claude can "make this P1" or answer "what's P1 and due this week?" in one call
+
+---
+
 ## v2.10.4 - Bulk task operations
 *May 2026*
 

README.md

@@ -50,6 +50,7 @@ I wanted a task system I understood completely - one where the data, the workflo
 - Deadline color coding - red when overdue, yellow when due within 3 days
 - Edit a task's title, deadline, project, and labels from the list; quick-set deadlines (Today, Tomorrow, This weekend, Next week) or clear them with one tap
 - Multi-select to act on many tasks at once - complete, move to a project, or set a deadline in one step
+- Set a priority (P1-P4) per task, shown as a colored dot and filterable
 - Checkbox completion with a clean animation - done tasks step aside, not deleted
 - Show/hide completed tasks and undo completion at any time
 - Task detail page with full status and completion history
@@ -122,7 +123,6 @@ That's it. The app opens in your browser.
 
 - Dark mode and custom themes
 - Dedicated device setup guide (Raspberry Pi, Term home server)
-- Task priority levels
 
 ### v3.0 - AI and integrations
 

backend/Tasklog.Api/Controllers/TasksController.cs

@@ -92,6 +92,13 @@ public async Task<IActionResult> GetAll([FromQuery] TaskFilterQuery filter)
                 query = query.Where(t => t.Title.ToLower().Contains(lowered));
             }
 
+            // priorities: OR within the list - a task matches if its priority is any of
+            // the requested values (e.g. ?priorities=1&priorities=2 = P1 or P2).
+            if (filter.Priorities is { Length: > 0 })
+            {
+                query = query.Where(t => filter.Priorities.Contains(t.Priority));
+            }
+
             var tasks = await query
                 .OrderByDescending(t => t.CreatedAt)
                 .ToListAsync();
@@ -124,13 +131,20 @@ public async Task<IActionResult> Create([FromBody] CreateTaskRequest request)
             if (string.IsNullOrWhiteSpace(request.Title))
                 return BadRequest(new { message = "Title is required." });
 
+            // Priority is optional on create; omitted defaults to 4 (P4 = none).
+            // When provided it must be on the P1-P4 scale.
+            var priority = request.Priority ?? 4;
+            if (priority < 1 || priority > 4)
+                return BadRequest(new { message = "Priority must be between 1 (P1) and 4 (P4)." });
+
             var task = new TaskModel
             {
                 Title = request.Title.Trim(),
                 Deadline = request.Deadline,
                 CreatedAt = DateTime.Now,
                 // Null means the task goes to Inbox (uncategorized).
-                ProjectId = request.ProjectId
+                ProjectId = request.ProjectId,
+                Priority = priority
             };
 
             _context.Tasks.Add(task);
@@ -187,6 +201,15 @@ public async Task<IActionResult> Update(int id, [FromBody] JsonElement body)
                 }
             }
 
+            // priority: present must be a number on the P1-P4 scale (1-4). There is no
+            // "clear" - P4 is the no-priority state. Absent leaves it unchanged.
+            if (body.TryGetProperty("priority", out var priorityEl))
+            {
+                if (priorityEl.ValueKind != JsonValueKind.Number || !priorityEl.TryGetInt32(out var p) || p < 1 || p > 4)
+                    return BadRequest(new { message = "Priority must be a number between 1 (P1) and 4 (P4)." });
+                task.Priority = p;
+            }
+
             await _context.SaveChangesAsync();
 
             return Ok(task);
@@ -356,8 +379,8 @@ public async Task<IActionResult> Bulk([FromBody] BulkTaskRequest request)
         }
     }
 
-    // Request body shape for task creation.
-    public record CreateTaskRequest(string Title, DateTime? Deadline, int? ProjectId);
+    // Request body shape for task creation. Priority is optional (defaults to 4 = none).
+    public record CreateTaskRequest(string Title, DateTime? Deadline, int? ProjectId, int? Priority = null);
 
     // Request body shape for toggling task completion.
     public record CompleteTaskRequest(bool IsCompleted);
@@ -386,12 +409,14 @@ public record BulkTaskData(bool? IsCompleted, int? ProjectId, string? Deadline);
     //   dueBefore / dueAfter - ISO 8601 dates (yyyy-MM-dd)
     //   completed / inbox    - "true" or "false"
     //   text                  - free substring for case-insensitive title match
+    //   priorities            - repeated keys (P1-P4 values), OR within
     public record TaskFilterQuery(
         int[]? ProjectIds,
         bool? Inbox,
         int[]? LabelIds,
         DateTime? DueBefore,
         DateTime? DueAfter,
         bool? Completed,
-        string? Text);
+        string? Text,
+        int[]? Priorities = null);
 }

backend/Tasklog.Api/Data/TasklogDbContext.cs

@@ -18,6 +18,13 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             modelBuilder.Entity<TaskModel>()
                 .HasMany(t => t.Labels)
                 .WithMany(l => l.Tasks);
+
+            // Priority defaults to 4 (P4 = none) at the DB level. This is what existing
+            // rows migrate to - without it, EF would use the CLR default of 0, which is
+            // outside the valid 1-4 range. New rows still set 4 via the model initializer.
+            modelBuilder.Entity<TaskModel>()
+                .Property(t => t.Priority)
+                .HasDefaultValue(4);
         }
     }
 }

backend/Tasklog.Api/Migrations/20260526211758_AddPriority.Designer.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Tasklog.Api.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPriority : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "Priority",
+                table: "Tasks",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 4);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Priority",
+                table: "Tasks");
+        }
+    }
+}

backend/Tasklog.Api/Migrations/20260526211758_AddPriority.cs

@@ -89,6 +89,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<bool>("IsCompleted")
                         .HasColumnType("INTEGER");
 
+                    b.Property<int>("Priority")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(4);
+
                     b.Property<int?>("ProjectId")
                         .HasColumnType("INTEGER");
 

backend/Tasklog.Api/Migrations/TasklogDbContextModelSnapshot.cs

@@ -18,6 +18,11 @@ public class TaskModel
         public int? ProjectId { get; set; }
         public Project? Project { get; set; }
 
+        // Priority on the Todoist P1-P4 scale: 1 = Urgent, 2 = High, 3 = Medium, 4 = None.
+        // P1 is the highest urgency (ascending sort = most urgent first). Non-null;
+        // P4 is the default "no priority" state, so existing rows migrate to 4.
+        public int Priority { get; set; } = 4;
+
         // Labels applied to this task. Many-to-many - a task can have multiple labels.
         public ICollection<Label> Labels { get; set; } = new List<Label>();