@task-mcp/shared 1.0.19 → 1.0.20

package/src/utils/natural-language.test.ts

@@ -1,5 +1,9 @@
 import { describe, test, expect } from "bun:test";
-import { parseTaskInput } from "./natural-language.js";
+import {
+  parseTaskInput,
+  parseInboxInput,
+  InputValidationError,
+} from "./natural-language.js";
 
 describe("parseTaskInput", () => {
   describe("priority parsing", () => {
@@ -179,4 +183,60 @@ describe("parseTaskInput", () => {
       expect(result.dueDate).toBeUndefined();
     });
   });
+
+  describe("empty content validation", () => {
+    test("throws error when input contains only tags", () => {
+      expect(() => parseTaskInput("#tag #only")).toThrow(InputValidationError);
+      expect(() => parseTaskInput("#tag #only")).toThrow(
+        "Task title cannot be empty after parsing"
+      );
+    });
+
+    test("throws error when input contains only metadata", () => {
+      expect(() => parseTaskInput("#dev !high @focus")).toThrow(
+        InputValidationError
+      );
+    });
+
+    test("throws error for empty input", () => {
+      expect(() => parseTaskInput("")).toThrow(InputValidationError);
+    });
+
+    test("throws error for whitespace-only input", () => {
+      expect(() => parseTaskInput("   ")).toThrow(InputValidationError);
+    });
+  });
+});
+
+describe("parseInboxInput", () => {
+  describe("basic parsing", () => {
+    test("parses content with tags", () => {
+      const result = parseInboxInput("GraphQL 도입 검토 #backend #연구");
+      expect(result.content).toBe("GraphQL 도입 검토");
+      expect(result.tags).toEqual(["backend", "연구"]);
+    });
+
+    test("parses content without tags", () => {
+      const result = parseInboxInput("Simple idea to capture");
+      expect(result.content).toBe("Simple idea to capture");
+      expect(result.tags).toBeUndefined();
+    });
+  });
+
+  describe("empty content validation", () => {
+    test("throws error when input contains only tags", () => {
+      expect(() => parseInboxInput("#tag #only")).toThrow(InputValidationError);
+      expect(() => parseInboxInput("#tag #only")).toThrow(
+        "Content cannot be empty after parsing"
+      );
+    });
+
+    test("throws error for empty input", () => {
+      expect(() => parseInboxInput("")).toThrow(InputValidationError);
+    });
+
+    test("throws error for whitespace-only input", () => {
+      expect(() => parseInboxInput("   ")).toThrow(InputValidationError);
+    });
+  });
 });

package/src/utils/natural-language.ts

@@ -110,6 +110,12 @@ export function parseInboxInput(input: string): InboxCreateInput {
   // Clean up and set content
   result.content = remaining.replace(/\s+/g, " ").trim();
 
+  if (!result.content) {
+    throw new InputValidationError(
+      "Content cannot be empty after parsing. Input contained only metadata (tags)."
+    );
+  }
+
   return result;
 }
 
@@ -223,6 +229,12 @@ export function parseTaskInput(input: string): TaskCreateInput {
   // Clean up extra spaces
   result.title = remaining.replace(/\s+/g, " ").trim();
 
+  if (!result.title) {
+    throw new InputValidationError(
+      "Task title cannot be empty after parsing. Input contained only metadata."
+    );
+  }
+
   return result;
 }
 

package/src/utils/priority-queue.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+import { PriorityQueue } from "./priority-queue";
+
+describe("PriorityQueue", () => {
+  test("creates empty queue", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    expect(pq.length).toBe(0);
+    expect(pq.isEmpty()).toBe(true);
+  });
+
+  test("pop from empty queue returns undefined", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    expect(pq.pop()).toBeUndefined();
+  });
+
+  test("peek from empty queue returns undefined", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    expect(pq.peek()).toBeUndefined();
+  });
+
+  test("single element operations", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    pq.push(42);
+    expect(pq.length).toBe(1);
+    expect(pq.peek()).toBe(42);
+    expect(pq.pop()).toBe(42);
+    expect(pq.isEmpty()).toBe(true);
+  });
+
+  test("maintains max-heap property (higher value first with a-b comparator)", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    pq.push(5);
+    pq.push(2);
+    pq.push(8);
+    pq.push(1);
+    pq.push(9);
+
+    // Max-heap: higher values come first
+    expect(pq.pop()).toBe(9);
+    expect(pq.pop()).toBe(8);
+    expect(pq.pop()).toBe(5);
+    expect(pq.pop()).toBe(2);
+    expect(pq.pop()).toBe(1);
+  });
+
+  test("works with reversed comparator (min-heap behavior)", () => {
+    const pq = new PriorityQueue<number>((a, b) => b - a);
+    pq.push(5);
+    pq.push(2);
+    pq.push(8);
+
+    // Reversed comparator: smaller values come first
+    expect(pq.pop()).toBe(2);
+    expect(pq.pop()).toBe(5);
+    expect(pq.pop()).toBe(8);
+  });
+
+  test("works with objects", () => {
+    interface Task {
+      priority: number;
+      name: string;
+    }
+    // Higher priority value = higher priority (max-heap)
+    const pq = new PriorityQueue<Task>((a, b) => a.priority - b.priority);
+
+    pq.push({ priority: 3, name: "high" });
+    pq.push({ priority: 1, name: "low" });
+    pq.push({ priority: 2, name: "medium" });
+
+    expect(pq.pop()?.name).toBe("high");
+    expect(pq.pop()?.name).toBe("medium");
+    expect(pq.pop()?.name).toBe("low");
+  });
+
+  test("length property tracks queue size correctly", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    expect(pq.length).toBe(0);
+
+    pq.push(1);
+    expect(pq.length).toBe(1);
+
+    pq.push(2);
+    pq.push(3);
+    expect(pq.length).toBe(3);
+
+    pq.pop();
+    expect(pq.length).toBe(2);
+
+    pq.pop();
+    pq.pop();
+    expect(pq.length).toBe(0);
+  });
+
+  test("peek does not remove element", () => {
+    const pq = new PriorityQueue<number>((a, b) => a - b);
+    pq.push(5);
+    pq.push(10);
+
+    expect(pq.peek()).toBe(10);
+    expect(pq.peek()).toBe(10);
+    expect(pq.length).toBe(2);
+  });
+});

package/src/utils/projection.ts

@@ -16,6 +16,14 @@ import type {
   PaginatedResponse,
 } from "../schemas/response-format.js";
 
+/**
+ * Exhaustiveness check helper for switch statements.
+ * TypeScript will error if a case is not handled.
+ */
+function assertNever(value: never): never {
+  throw new Error(`Unexpected value: ${value}`);
+}
+
 /**
  * Project a single task to the specified format
  */
@@ -42,8 +50,9 @@ export function projectTask(task: Task, format: ResponseFormat): TaskSummary | T
       };
 
     case "detailed":
-    default:
       return task;
+    default:
+      return assertNever(format);
   }
 }
 
@@ -106,8 +115,9 @@ export function projectInboxItem(
       };
 
     case "detailed":
-    default:
       return item;
+    default:
+      return assertNever(format);
   }
 }
 
@@ -226,8 +236,9 @@ export function sortTasks(
       }
 
       case "updatedAt":
-      default:
         return new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+      default:
+        return assertNever(secondarySort);
     }
   });
 }

package/src/utils/workspace.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import {
+  normalizeWorkspace,
+  detectWorkspaceSync,
+  detectWorkspace,
+  getWorkspaceFromPath,
+  getGitRepoRoot,
+  getGitRepoRootSync,
+} from "./workspace";
+
+describe("normalizeWorkspace", () => {
+  test("converts to lowercase", () => {
+    expect(normalizeWorkspace("MyProject")).toBe("myproject");
+  });
+
+  test("replaces spaces with hyphens", () => {
+    expect(normalizeWorkspace("my project")).toBe("my-project");
+  });
+
+  test("removes special characters", () => {
+    expect(normalizeWorkspace("my@project!")).toBe("myproject");
+  });
+
+  test("handles empty string", () => {
+    expect(normalizeWorkspace("")).toBe("default");
+  });
+
+  test("keeps hyphens and underscores", () => {
+    expect(normalizeWorkspace("my-project_name")).toBe("my-project_name");
+  });
+
+  test("trims leading and trailing hyphens", () => {
+    expect(normalizeWorkspace("--my-project--")).toBe("my-project");
+  });
+
+  test("handles multiple spaces", () => {
+    // Multiple spaces become multiple hyphens, then cleaned by special char removal
+    expect(normalizeWorkspace("my   project")).toBe("my-project");
+  });
+
+  test("handles mixed case with special chars", () => {
+    expect(normalizeWorkspace("My@Project#Name")).toBe("myprojectname");
+  });
+});
+
+describe("getWorkspaceFromPath", () => {
+  test("extracts workspace from path", () => {
+    expect(getWorkspaceFromPath("/home/user/projects/my-app")).toBe("my-app");
+  });
+
+  test("handles path with .tasks suffix", () => {
+    expect(getWorkspaceFromPath("/projects/my-app/.tasks")).toBe("my-app");
+  });
+
+  test("handles path with trailing slash", () => {
+    expect(getWorkspaceFromPath("/projects/my-app/.tasks/")).toBe("my-app");
+  });
+
+  test("normalizes the extracted name", () => {
+    expect(getWorkspaceFromPath("/projects/My App")).toBe("my-app");
+  });
+});
+
+describe("getGitRepoRootSync", () => {
+  test("returns string or null for current directory", () => {
+    const result = getGitRepoRootSync();
+    expect(result === null || typeof result === "string").toBe(true);
+  });
+
+  test("returns null for non-git directory", () => {
+    const result = getGitRepoRootSync("/tmp");
+    expect(result).toBeNull();
+  });
+});
+
+describe("getGitRepoRoot", () => {
+  test("returns string or null for current directory", async () => {
+    const result = await getGitRepoRoot();
+    expect(result === null || typeof result === "string").toBe(true);
+  });
+
+  test("returns null for non-git directory", async () => {
+    const result = await getGitRepoRoot("/tmp");
+    expect(result).toBeNull();
+  });
+});
+
+describe("detectWorkspaceSync", () => {
+  test("returns a workspace name", () => {
+    const workspace = detectWorkspaceSync();
+    expect(typeof workspace).toBe("string");
+    expect(workspace.length).toBeGreaterThan(0);
+  });
+
+  test("uses tasksDir path when provided and no git repo", () => {
+    // This tests the fallback to tasksDir when in a non-git directory
+    const workspace = detectWorkspaceSync("/some/path/my-project/.tasks");
+    expect(typeof workspace).toBe("string");
+  });
+
+  test("returns normalized workspace name", () => {
+    const workspace = detectWorkspaceSync();
+    // Should be lowercase with no special characters except - and _
+    expect(workspace).toMatch(/^[a-z0-9_-]+$/);
+  });
+});
+
+describe("detectWorkspace", () => {
+  test("returns a workspace name asynchronously", async () => {
+    const workspace = await detectWorkspace();
+    expect(typeof workspace).toBe("string");
+    expect(workspace.length).toBeGreaterThan(0);
+  });
+
+  test("uses tasksDir path when provided", async () => {
+    const workspace = await detectWorkspace("/some/path/test-project/.tasks");
+    expect(typeof workspace).toBe("string");
+  });
+
+  test("returns normalized workspace name", async () => {
+    const workspace = await detectWorkspace();
+    // Should be lowercase with no special characters except - and _
+    expect(workspace).toMatch(/^[a-z0-9_-]+$/);
+  });
+});