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

- TaskManager.remove(id): removes task by ID, returns true/false
- TaskManager.update(id, changes): updates title/description/priority only
- TaskManager.sortBy(field): sorts by priority, createdAt, or status without mutating state
- string-utils truncate(): truncates at word boundaries, '...' counts toward maxLength
- Added comprehensive test suites for all new functionality (33 tests total)

Author: stooit

src/string-utils.ts

@@ -11,9 +11,13 @@ 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 (str.length <= maxLength) return str
+  const cutoff = maxLength - 3 // reserve 3 chars for "..."
+  const lastSpace = str.lastIndexOf(" ", cutoff)
+  const end = lastSpace > 0 ? lastSpace : cutoff
+  return str.slice(0, end) + "..."
+}
 
 export function slugify(str: string): string {
   return str

src/task-manager.ts

@@ -52,7 +52,26 @@ 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 priorityOrder: Record<Priority, number> = { high: 0, medium: 1, low: 2 }
+    const statusOrder: Record<Status, number> = { in_progress: 0, pending: 1, completed: 2 }
+    return Array.from(this.tasks.values()).sort((a, b) => {
+      if (field === "priority") return priorityOrder[a.priority] - priorityOrder[b.priority]
+      if (field === "status") return statusOrder[a.status] - statusOrder[b.status]
+      return a.createdAt.getTime() - b.createdAt.getTime()
+    })
+  }
 }

test/string-utils.test.ts

@@ -0,0 +1,60 @@
+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 equal to maxLength", () => {
+    expect(truncate("hello", 5)).toBe("hello")
+  })
+
+  test("truncates and appends '...' when longer than maxLength", () => {
+    const result = truncate("hello world", 8)
+    expect(result).toBe("hello...")
+  })
+
+  test("result length does not exceed maxLength", () => {
+    const result = truncate("the quick brown fox", 10)
+    expect(result.length).toBeLessThanOrEqual(10)
+  })
+
+  test("'...' counts toward maxLength", () => {
+    // maxLength=8 means 5 chars of content + "..."
+    const result = truncate("abcdefghij", 8)
+    expect(result.length).toBe(8)
+    expect(result.endsWith("...")).toBe(true)
+  })
+
+  test("does not cut in the middle of a word — finds last space", () => {
+    // "the quick" = 9 chars, maxLength=12 → cutoff=9, last space before 9 is at index 3
+    const result = truncate("the quick brown fox", 12)
+    expect(result).toBe("the quick...")
+  })
+
+  test("handles single long word with no spaces — cuts at character boundary", () => {
+    // cutoff = 10 - 3 = 7, no space found, so slice(0, 7) + "..." = 10 chars total
+    const result = truncate("superlongwordwithoutspaces", 10)
+    expect(result).toBe("superlo...")
+    expect(result.length).toBeLessThanOrEqual(10)
+  })
+
+  test("handles single long word — result ends with '...'", () => {
+    const result = truncate("pneumonoultramicroscopicsilicovolcanoconiosis", 15)
+    expect(result.endsWith("...")).toBe(true)
+    expect(result.length).toBeLessThanOrEqual(15)
+  })
+
+  test("truncates sentence at word boundary, not mid-word", () => {
+    // cutoff = 14 - 3 = 11, lastIndexOf(" ", 11) = 7 ("one two")
+    // slice(0, 7) + "..." = "one two..." (10 chars, within maxLength 14)
+    const result = truncate("one two three four five", 14)
+    expect(result).toBe("one two...")
+    expect(result.length).toBeLessThanOrEqual(14)
+  })
+
+  test("empty string returns empty string", () => {
+    expect(truncate("", 5)).toBe("")
+  })
+})

test/task-manager.test.ts

@@ -0,0 +1,171 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import { TaskManager } from "../src/task-manager"
+
+describe("TaskManager", () => {
+  let tm: TaskManager
+
+  beforeEach(() => {
+    tm = new TaskManager()
+  })
+
+  describe("remove", () => {
+    test("returns true and removes an existing task", () => {
+      const task = tm.add("Task A")
+      expect(tm.remove(task.id)).toBe(true)
+    })
+
+    test("task is no longer accessible after removal", () => {
+      const task = tm.add("Task A")
+      tm.remove(task.id)
+      expect(tm.get(task.id)).toBeUndefined()
+    })
+
+    test("removed task no longer appears in list()", () => {
+      const task = tm.add("Task A")
+      tm.remove(task.id)
+      expect(tm.list().find((t) => t.id === task.id)).toBeUndefined()
+    })
+
+    test("returns false for a non-existent ID", () => {
+      expect(tm.remove("999")).toBe(false)
+    })
+
+    test("removing one task does not affect others", () => {
+      const a = tm.add("Task A")
+      const b = tm.add("Task B")
+      tm.remove(a.id)
+      expect(tm.get(b.id)).toBeDefined()
+    })
+  })
+
+  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("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("partial update only changes specified fields", () => {
+      const task = tm.add("Task", "low", "desc")
+      tm.update(task.id, { title: "New Title" })
+      const updated = tm.get(task.id)!
+      expect(updated.title).toBe("New Title")
+      expect(updated.priority).toBe("low")
+      expect(updated.description).toBe("desc")
+    })
+
+    test("returns the updated task object", () => {
+      const task = tm.add("Task")
+      const result = tm.update(task.id, { title: "Changed" })
+      expect(result).toBeDefined()
+      expect(result?.title).toBe("Changed")
+    })
+  })
+
+  describe("sortBy priority", () => {
+    test("high tasks come before medium and 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("tasks with same priority maintain relative order", () => {
+      const a = tm.add("High A", "high")
+      const b = tm.add("High B", "high")
+      const sorted = tm.sortBy("priority")
+      const ids = sorted.filter((t) => t.priority === "high").map((t) => t.id)
+      expect(ids).toEqual([a.id, b.id])
+    })
+  })
+
+  describe("sortBy status", () => {
+    test("in_progress comes first, then pending, then completed", () => {
+      const pending = tm.add("Pending")
+      const completed = tm.add("Completed")
+      tm.complete(completed.id)
+      const inProgress = tm.add("In Progress")
+      inProgress.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")
+    })
+  })
+
+  describe("sortBy createdAt", () => {
+    test("oldest tasks come first", async () => {
+      const a = tm.add("First")
+      await new Promise((r) => setTimeout(r, 5))
+      const b = tm.add("Second")
+      await new Promise((r) => setTimeout(r, 5))
+      const c = tm.add("Third")
+
+      const sorted = tm.sortBy("createdAt")
+      expect(sorted.map((t) => t.id)).toEqual([a.id, b.id, c.id])
+    })
+  })
+
+  describe("sortBy does not mutate internal state", () => {
+    test("list() returns original insertion order after sortBy", () => {
+      tm.add("Low", "low")
+      tm.add("High", "high")
+      tm.add("Medium", "medium")
+
+      const beforeSort = tm.list().map((t) => t.id)
+      tm.sortBy("priority")
+      const afterSort = tm.list().map((t) => t.id)
+
+      expect(afterSort).toEqual(beforeSort)
+    })
+  })
+})