Merge feature/labels-#30: Labels and Filtering (v2.4)

Author: hydraInsurgent

.claude/settings.local.json

@@ -26,7 +26,8 @@
       "Bash(gh repo view:*)",
       "Bash(gh release list:*)",
       "Bash(gh issue list:*)",
-      "Bash(npx jest:*)"
+      "Bash(npx jest:*)",
+      "Bash(cd:*)"
     ],
     "additionalDirectories": [
       "/tmp"

CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ---
 
+## v2.4 - Labels and Filtering
+*March 2026*
+
+### What changed
+
+**Backend**
+- New `Labels` table with many-to-many relationship to Tasks (implicit join table via EF Core)
+- New endpoints: `GET /api/labels`, `POST /api/labels`, `PATCH /api/labels/{id}`, `DELETE /api/labels/{id}`
+- New endpoint: `PATCH /api/tasks/{id}/labels` - replaces the full label set on a task
+- Label name uniqueness enforced (case-insensitive, returns 409 Conflict)
+- Label ID validation on assignment (returns 400 with invalid IDs)
+- Task queries now eager-load labels via `.Include(t => t.Labels)`
+
+**Frontend**
+- Labels dashboard page (`/labels`) accessible from the sidebar - full CRUD with inline rename, color picker, and delete with confirmation
+- 10-color VIBGYOR palette for label colors, auto-cycling on creation
+- Labels field in AddTaskForm with autocomplete, multi-select, and auto-create on Enter
+- Labels row on task detail page with add/remove via AssignLabelsButton (optimistic updates)
+- Label chips (`#labelname`) shown on mobile task cards
+- Filter panel popover (three-dot menu in task list header) with label, project, and date filters
+- Filter state persists across navigation via sessionStorage
+- New components: `LabelsClient`, `FilterPanel`, `ColorPicker`, `LabelChip`, `AssignLabelsButton`
+
+**Tests**
+- 15 new tests for `LabelsController` (CRUD, validation, uniqueness, color range)
+
+---
+
 ## v2.3 - Mobile Task Cards
 *March 2026*
 

backend/Tasklog.Api/Controllers/LabelsController.cs

@@ -0,0 +1,119 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Tasklog.Api.Data;
+using Tasklog.Api.Models;
+
+namespace Tasklog.Api.Controllers
+{
+    [ApiController]
+    [Route("api/labels")]
+    public class LabelsController : ControllerBase
+    {
+        private readonly TasklogDbContext _context;
+
+        public LabelsController(TasklogDbContext context)
+        {
+            _context = context;
+        }
+
+        // GET /api/labels
+        // Returns all labels ordered alphabetically by name.
+        [HttpGet]
+        public async Task<IActionResult> GetAll()
+        {
+            var labels = await _context.Labels
+                .OrderBy(l => l.Name)
+                .ToListAsync();
+
+            return Ok(labels);
+        }
+
+        // POST /api/labels
+        // Creates a new label. Expects { name: string, colorIndex: int }.
+        [HttpPost]
+        public async Task<IActionResult> Create([FromBody] CreateLabelRequest request)
+        {
+            if (string.IsNullOrWhiteSpace(request.Name))
+                return BadRequest(new { message = "Label name is required." });
+
+            if (request.ColorIndex < 0 || request.ColorIndex > 9)
+                return BadRequest(new { message = "ColorIndex must be between 0 and 9." });
+
+            // Reject the request if a label with the same name already exists (case-insensitive).
+            var trimmedName = request.Name.Trim();
+            var nameExists = await _context.Labels
+                .AnyAsync(l => l.Name.ToLower() == trimmedName.ToLower());
+
+            if (nameExists)
+                return Conflict(new { message = $"A label named \"{trimmedName}\" already exists." });
+
+            var label = new Label
+            {
+                Name = trimmedName,
+                ColorIndex = request.ColorIndex,
+                CreatedAt = DateTime.UtcNow
+            };
+
+            _context.Labels.Add(label);
+            await _context.SaveChangesAsync();
+
+            return CreatedAtAction(nameof(GetAll), new { id = label.Id }, label);
+        }
+
+        // PATCH /api/labels/{id}
+        // Updates a label's name and/or color. Returns the updated label.
+        [HttpPatch("{id:int}")]
+        public async Task<IActionResult> Update(int id, [FromBody] UpdateLabelRequest request)
+        {
+            if (string.IsNullOrWhiteSpace(request.Name))
+                return BadRequest(new { message = "Label name is required." });
+
+            if (request.ColorIndex < 0 || request.ColorIndex > 9)
+                return BadRequest(new { message = "ColorIndex must be between 0 and 9." });
+
+            var label = await _context.Labels.FindAsync(id);
+
+            if (label is null)
+                return NotFound(new { message = $"Label {id} not found." });
+
+            // Reject the rename if another label already has the same name (case-insensitive).
+            // The current label is excluded from the check so saving with no name change still works.
+            var trimmedName = request.Name.Trim();
+            var nameConflict = await _context.Labels
+                .AnyAsync(l => l.Id != id && l.Name.ToLower() == trimmedName.ToLower());
+
+            if (nameConflict)
+                return Conflict(new { message = $"A label named \"{trimmedName}\" already exists." });
+
+            label.Name = trimmedName;
+            label.ColorIndex = request.ColorIndex;
+            await _context.SaveChangesAsync();
+
+            return Ok(label);
+        }
+
+        // DELETE /api/labels/{id}
+        // Deletes a label. The join table entries are cascade-deleted by the database,
+        // so this safely unlinks the label from all tasks without deleting those tasks.
+        // Returns 204 No Content on success, 404 if not found.
+        [HttpDelete("{id:int}")]
+        public async Task<IActionResult> Delete(int id)
+        {
+            var label = await _context.Labels.FindAsync(id);
+
+            if (label is null)
+                return NotFound(new { message = $"Label {id} not found." });
+
+            _context.Labels.Remove(label);
+            await _context.SaveChangesAsync();
+
+            return NoContent();
+        }
+    }
+
+    // Request body for label creation.
+    public record CreateLabelRequest(string Name, int ColorIndex);
+
+    // Request body for label update (name and/or color).
+    public record UpdateLabelRequest(string Name, int ColorIndex);
+}

backend/Tasklog.Api/Controllers/TasksController.cs

@@ -18,10 +18,12 @@ public TasksController(TasklogDbContext context)
 
         // GET /api/tasks
         // Returns all tasks ordered by creation date, newest first.
+        // Labels are eagerly loaded so callers don't need a second request.
         [HttpGet]
         public async Task<IActionResult> GetAll()
         {
             var tasks = await _context.Tasks
+                .Include(t => t.Labels)
                 .OrderByDescending(t => t.CreatedAt)
                 .ToListAsync();
 
@@ -30,10 +32,14 @@ public async Task<IActionResult> GetAll()
 
         // GET /api/tasks/{id}
         // Returns a single task by ID, or 404 if not found.
+        // Labels are eagerly loaded alongside the task.
         [HttpGet("{id:int}")]
         public async Task<IActionResult> GetById(int id)
         {
-            var task = await _context.Tasks.FindAsync(id);
+            // FindAsync does not support Include, so we use FirstOrDefaultAsync here.
+            var task = await _context.Tasks
+                .Include(t => t.Labels)
+                .FirstOrDefaultAsync(t => t.Id == id);
 
             if (task is null)
                 return NotFound(new { message = $"Task {id} not found." });
@@ -114,6 +120,46 @@ public async Task<IActionResult> AssignProject(int id, [FromBody] AssignProjectR
 
             return Ok(task);
         }
+
+        // PATCH /api/tasks/{id}/labels
+        // Replaces the full set of labels on a task. Accepts an array of label IDs.
+        // Sends back the updated task with labels included.
+        // Send an empty array to remove all labels from the task.
+        [HttpPatch("{id:int}/labels")]
+        public async Task<IActionResult> SetLabels(int id, [FromBody] SetTaskLabelsRequest request)
+        {
+            // Load the task with its current labels so EF can track the relationship changes.
+            var task = await _context.Tasks
+                .Include(t => t.Labels)
+                .FirstOrDefaultAsync(t => t.Id == id);
+
+            if (task is null)
+                return NotFound(new { message = $"Task {id} not found." });
+
+            // Load the requested labels and reject the request if any IDs don't exist.
+            // An empty array is valid - it clears all labels from the task.
+            var newLabels = await _context.Labels
+                .Where(l => request.LabelIds.Contains(l.Id))
+                .ToListAsync();
+
+            if (request.LabelIds.Length > 0)
+            {
+                var foundIds = newLabels.Select(l => l.Id).ToHashSet();
+                var invalidIds = request.LabelIds.Where(id => !foundIds.Contains(id)).ToList();
+
+                if (invalidIds.Any())
+                    return BadRequest(new { message = $"Label IDs not found: {string.Join(", ", invalidIds)}." });
+            }
+
+            // Replace the current label collection. EF Core handles join table updates.
+            task.Labels.Clear();
+            foreach (var label in newLabels)
+                task.Labels.Add(label);
+
+            await _context.SaveChangesAsync();
+
+            return Ok(task);
+        }
     }
 
     // Request body shape for task creation.
@@ -124,4 +170,7 @@ public record CompleteTaskRequest(bool IsCompleted);
 
     // Request body shape for assigning or unassigning a project on a task.
     public record AssignProjectRequest(int? ProjectId);
+
+    // Request body shape for replacing a task's full label set.
+    public record SetTaskLabelsRequest(int[] LabelIds);
 }

backend/Tasklog.Api/Data/TasklogDbContext.cs

@@ -9,5 +9,15 @@ public TasklogDbContext(DbContextOptions<TasklogDbContext> options) : base(optio
 
         public DbSet<TaskModel> Tasks => Set<TaskModel>();
         public DbSet<Project> Projects => Set<Project>();
+        public DbSet<Label> Labels => Set<Label>();
+
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            // Configure the implicit many-to-many join table between tasks and labels.
+            // EF Core creates a "LabelTaskModel" join table automatically from these nav properties.
+            modelBuilder.Entity<TaskModel>()
+                .HasMany(t => t.Labels)
+                .WithMany(l => l.Tasks);
+        }
     }
 }