feat: implement remove, update, sortBy, and truncate with comprehensive tests

- TaskManager.remove(id): removes task by ID, returns true/false
- TaskManager.update(id, changes): updates title/description/priority only, returns updated task or undefined
- TaskManager.sortBy(field): sorts by priority (high>medium>low), status (in_progress>pending>completed), or createdAt (ascending)
- truncate(str, maxLength): word-boundary truncation with '...' counting towards maxLength
- 36 tests across 3 files, all passing

Author: QuantCode Agent

src/string-utils.ts

@@ -11,9 +11,29 @@ export function reverse(str: string): string {
   return str.split("").reverse().join("")
 }
 
-// TODO: implement truncate function
-// Should truncate a string to maxLength and add "..." if truncated
-// Should not truncate in the middle of a word
+export function truncate(str: string, maxLength: number): string {
+  if (maxLength <= 0) return ""
+  if (str.length <= maxLength) return str
+  if (maxLength <= 3) return ".".repeat(maxLength)
+
+  // We need to fit text + "..." within maxLength
+  const available = maxLength - 3
+  const candidate = str.slice(0, available)
+
+  // If the character right after the cut is a space or we're at end, clean word boundary
+  if (str[available] === " " || available >= str.length) {
+    return candidate + "..."
+  }
+
+  // Find last space in candidate to avoid cutting mid-word
+  const lastSpace = candidate.lastIndexOf(" ")
+  if (lastSpace === -1) {
+    // No space found — truncate at character level
+    return candidate + "..."
+  }
+
+  return candidate.slice(0, lastSpace) + "..."
+}
 
 export function slugify(str: string): string {
   return str

src/task-manager.ts

@@ -52,7 +52,29 @@ export class TaskManager {
     return true
   }
 
-  // TODO: implement remove method
-  // TODO: implement update method to change title/description/priority
-  // TODO: implement sortBy method (by priority, createdAt, or status)
+  remove(id: string): boolean {
+    return this.tasks.delete(id)
+  }
+
+  update(id: string, changes: Partial<Pick<Task, "title" | "description" | "priority">>): Task | undefined {
+    const task = this.tasks.get(id)
+    if (!task) return undefined
+    if (changes.title !== undefined) task.title = changes.title
+    if (changes.description !== undefined) task.description = changes.description
+    if (changes.priority !== undefined) task.priority = changes.priority
+    return task
+  }
+
+  sortBy(field: "priority" | "createdAt" | "status"): Task[] {
+    const tasks = Array.from(this.tasks.values())
+    const priorityOrder: Record<Priority, number> = { high: 0, medium: 1, low: 2 }
+    const statusOrder: Record<Status, number> = { in_progress: 0, pending: 1, completed: 2 }
+
+    return tasks.slice().sort((a, b) => {
+      if (field === "priority") return priorityOrder[a.priority] - priorityOrder[b.priority]
+      if (field === "status") return statusOrder[a.status] - statusOrder[b.status]
+      // createdAt ascending
+      return a.createdAt.getTime() - b.createdAt.getTime()
+    })
+  }
 }

test/string-utils.test.ts

@@ -0,0 +1,72 @@
+import { describe, test, expect } from "bun:test"
+import { truncate } from "../src/string-utils"
+
+describe("truncate", () => {
+  test("returns string unchanged when shorter than maxLength", () => {
+    expect(truncate("hello", 10)).toBe("hello")
+  })
+
+  test("returns string unchanged when exactly equal to maxLength", () => {
+    expect(truncate("hello", 5)).toBe("hello")
+  })
+
+  test("truncates at word boundary, not mid-word", () => {
+    // "Hello world" (11 chars), maxLength=8 → available=5 → "Hello" + "..." = "Hello..."
+    expect(truncate("Hello world", 8)).toBe("Hello...")
+  })
+
+  test("appended '...' counts toward maxLength", () => {
+    const result = truncate("Hello world foo", 8)
+    expect(result.length).toBeLessThanOrEqual(8)
+    expect(result.endsWith("...")).toBe(true)
+  })
+
+  test("truncates a longer sentence at word boundary", () => {
+    // "The quick brown fox" maxLength=13 → available=10 → "The quick " → last space at 9
+    // "The quick" + "..." = "The quick..." (12 chars ≤ 13)
+    const result = truncate("The quick brown fox", 13)
+    expect(result).toBe("The quick...")
+    expect(result.length).toBeLessThanOrEqual(13)
+  })
+
+  test("edge case: maxLength=0 returns empty string", () => {
+    expect(truncate("hello", 0)).toBe("")
+  })
+
+  test("edge case: maxLength=1 returns '.'", () => {
+    expect(truncate("hello", 1)).toBe(".")
+  })
+
+  test("edge case: maxLength=2 returns '..'", () => {
+    expect(truncate("hello", 2)).toBe("..")
+  })
+
+  test("edge case: maxLength=3 returns '...'", () => {
+    expect(truncate("hello world", 3)).toBe("...")
+  })
+
+  test("no spaces before cut point — truncates at character level", () => {
+    // "superlongword" maxLength=8 → available=5 → "super" no space → "super..."
+    expect(truncate("superlongword", 8)).toBe("super...")
+  })
+
+  test("empty string returns empty string", () => {
+    expect(truncate("", 10)).toBe("")
+  })
+
+  test("empty string with maxLength=0 returns empty string", () => {
+    expect(truncate("", 0)).toBe("")
+  })
+
+  test("does not leave trailing space before '...'", () => {
+    // "Hello world" maxLength=9 → available=6 → "Hello " → last space at 5 → "Hello" + "..."
+    const result = truncate("Hello world", 9)
+    expect(result).not.toMatch(/ \.\.\./)
+    expect(result.endsWith("...")).toBe(true)
+  })
+
+  test("word at exact boundary — no truncation needed", () => {
+    // "Hi there" = 8 chars, maxLength=8 → unchanged
+    expect(truncate("Hi there", 8)).toBe("Hi there")
+  })
+})

test/task-manager.test.ts

@@ -0,0 +1,170 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import { TaskManager } from "../src/task-manager"
+
+describe("TaskManager", () => {
+  let tm: TaskManager
+
+  beforeEach(() => {
+    tm = new TaskManager()
+  })
+
+  // ── remove ────────────────────────────────────────────────────────────────
+
+  describe("remove", () => {
+    test("returns true and removes an existing task", () => {
+      const task = tm.add("Task A")
+      expect(tm.remove(task.id)).toBe(true)
+      expect(tm.get(task.id)).toBeUndefined()
+    })
+
+    test("returns false for a non-existent id", () => {
+      expect(tm.remove("999")).toBe(false)
+    })
+
+    test("task is no longer in list after removal", () => {
+      const task = tm.add("Task B")
+      tm.remove(task.id)
+      expect(tm.list().find((t) => t.id === task.id)).toBeUndefined()
+    })
+
+    test("removing one task does not affect others", () => {
+      const a = tm.add("A")
+      const b = tm.add("B")
+      tm.remove(a.id)
+      expect(tm.get(b.id)).toBeDefined()
+    })
+  })
+
+  // ── update ────────────────────────────────────────────────────────────────
+
+  describe("update", () => {
+    test("updates title", () => {
+      const task = tm.add("Original")
+      const updated = tm.update(task.id, { title: "Updated" })
+      expect(updated?.title).toBe("Updated")
+    })
+
+    test("updates description", () => {
+      const task = tm.add("Task", "medium", "old desc")
+      const updated = tm.update(task.id, { description: "new desc" })
+      expect(updated?.description).toBe("new desc")
+    })
+
+    test("updates priority", () => {
+      const task = tm.add("Task", "low")
+      const updated = tm.update(task.id, { priority: "high" })
+      expect(updated?.priority).toBe("high")
+    })
+
+    test("updates multiple fields at once", () => {
+      const task = tm.add("Old title", "low", "old desc")
+      const updated = tm.update(task.id, { title: "New title", priority: "high", description: "new desc" })
+      expect(updated?.title).toBe("New title")
+      expect(updated?.priority).toBe("high")
+      expect(updated?.description).toBe("new desc")
+    })
+
+    test("returns undefined for non-existent id", () => {
+      expect(tm.update("999", { title: "X" })).toBeUndefined()
+    })
+
+    test("does not change id", () => {
+      const task = tm.add("Task")
+      const originalId = task.id
+      tm.update(task.id, { title: "New" })
+      expect(tm.get(originalId)?.id).toBe(originalId)
+    })
+
+    test("does not change status", () => {
+      const task = tm.add("Task")
+      tm.complete(task.id)
+      tm.update(task.id, { title: "New" })
+      expect(tm.get(task.id)?.status).toBe("completed")
+    })
+
+    test("does not change createdAt", () => {
+      const task = tm.add("Task")
+      const originalCreatedAt = task.createdAt
+      tm.update(task.id, { title: "New" })
+      expect(tm.get(task.id)?.createdAt).toEqual(originalCreatedAt)
+    })
+
+    test("does not change completedAt", () => {
+      const task = tm.add("Task")
+      tm.complete(task.id)
+      const completedAt = tm.get(task.id)!.completedAt
+      tm.update(task.id, { title: "New" })
+      expect(tm.get(task.id)?.completedAt).toEqual(completedAt)
+    })
+
+    test("returns the updated task object", () => {
+      const task = tm.add("Task")
+      const result = tm.update(task.id, { title: "Updated" })
+      expect(result).toBeDefined()
+      expect(result?.title).toBe("Updated")
+    })
+  })
+
+  // ── sortBy ────────────────────────────────────────────────────────────────
+
+  describe("sortBy", () => {
+    test("sorts by priority: high first, then medium, then low", () => {
+      tm.add("Low task", "low")
+      tm.add("High task", "high")
+      tm.add("Medium task", "medium")
+
+      const sorted = tm.sortBy("priority")
+      expect(sorted[0].priority).toBe("high")
+      expect(sorted[1].priority).toBe("medium")
+      expect(sorted[2].priority).toBe("low")
+    })
+
+    test("sorts by status: in_progress first, then pending, then completed", () => {
+      const t1 = tm.add("Pending task")
+      const t2 = tm.add("Completed task")
+      const t3 = tm.add("In-progress task")
+      tm.complete(t2.id)
+      // manually set in_progress
+      const task3 = tm.get(t3.id)!
+      task3.status = "in_progress"
+
+      const sorted = tm.sortBy("status")
+      expect(sorted[0].status).toBe("in_progress")
+      expect(sorted[1].status).toBe("pending")
+      expect(sorted[2].status).toBe("completed")
+    })
+
+    test("sorts by createdAt ascending (earliest first)", async () => {
+      const t1 = tm.add("First")
+      await new Promise((r) => setTimeout(r, 5))
+      const t2 = tm.add("Second")
+      await new Promise((r) => setTimeout(r, 5))
+      const t3 = tm.add("Third")
+
+      const sorted = tm.sortBy("createdAt")
+      expect(sorted[0].id).toBe(t1.id)
+      expect(sorted[1].id).toBe(t2.id)
+      expect(sorted[2].id).toBe(t3.id)
+    })
+
+    test("returns a new array (does not mutate internal state)", () => {
+      tm.add("Low", "low")
+      tm.add("High", "high")
+
+      const before = tm.list()
+      const sorted = tm.sortBy("priority")
+
+      // sorted is a different array reference
+      expect(sorted).not.toBe(before)
+      // internal list order is unchanged
+      expect(tm.list()[0].priority).toBe("low")
+    })
+
+    test("returns all tasks when sorting", () => {
+      tm.add("A", "high")
+      tm.add("B", "medium")
+      tm.add("C", "low")
+      expect(tm.sortBy("priority")).toHaveLength(3)
+    })
+  })
+})