@task-mcp/shared 1.0.22 → 1.0.24

package/src/algorithms/topological-sort.test.ts

@@ -0,0 +1,182 @@
+import { describe, test, expect } from "bun:test";
+import {
+  priorityToNumber,
+  topologicalSort,
+  wouldCreateCycle,
+  findDependents,
+  findDependencies,
+} from "./topological-sort.js";
+import type { Task } from "../schemas/task.js";
+
+// Helper to create mock tasks
+function createTask(id: string, priority: string = "medium", deps: string[] = []): Task {
+  return {
+    id,
+    title: `Task ${id}`,
+    status: "pending",
+    priority: priority as Task["priority"],
+    workspace: "test-workspace",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    dependencies: deps.map((depId) => ({ taskId: depId, type: "blocked_by" as const })),
+  };
+}
+
+describe("priorityToNumber", () => {
+  test("converts critical to 4", () => {
+    expect(priorityToNumber("critical")).toBe(4);
+  });
+
+  test("converts high to 3", () => {
+    expect(priorityToNumber("high")).toBe(3);
+  });
+
+  test("converts medium to 2", () => {
+    expect(priorityToNumber("medium")).toBe(2);
+  });
+
+  test("converts low to 1", () => {
+    expect(priorityToNumber("low")).toBe(1);
+  });
+
+  test("defaults to 2 for unknown priority", () => {
+    expect(priorityToNumber("unknown")).toBe(2);
+  });
+});
+
+describe("topologicalSort", () => {
+  test("returns empty array for empty input", () => {
+    const result = topologicalSort([]);
+    expect(result).toEqual([]);
+  });
+
+  test("returns single task unchanged", () => {
+    const tasks = [createTask("A")];
+    const result = topologicalSort(tasks);
+    expect(result.length).toBe(1);
+    expect(result[0]!.id).toBe("A");
+  });
+
+  test("sorts by dependency order", () => {
+    // B depends on A, so A should come first
+    const tasks = [createTask("B", "high", ["A"]), createTask("A", "low")];
+    const result = topologicalSort(tasks);
+    expect(result[0]!.id).toBe("A");
+    expect(result[1]!.id).toBe("B");
+  });
+
+  test("respects priority when no dependencies", () => {
+    const tasks = [createTask("A", "low"), createTask("B", "critical"), createTask("C", "high")];
+    const result = topologicalSort(tasks);
+    expect(result[0]!.id).toBe("B"); // critical first
+    expect(result[1]!.id).toBe("C"); // then high
+    expect(result[2]!.id).toBe("A"); // then low
+  });
+
+  test("handles chain of dependencies", () => {
+    // C -> B -> A (C depends on B, B depends on A)
+    const tasks = [
+      createTask("C", "critical", ["B"]),
+      createTask("B", "high", ["A"]),
+      createTask("A", "low"),
+    ];
+    const result = topologicalSort(tasks);
+    expect(result.map((t) => t.id)).toEqual(["A", "B", "C"]);
+  });
+
+  test("throws on circular dependency", () => {
+    // A -> B -> A
+    const tasks = [createTask("A", "medium", ["B"]), createTask("B", "medium", ["A"])];
+    expect(() => topologicalSort(tasks)).toThrow(/Circular dependency/);
+  });
+
+  test("handles diamond dependency", () => {
+    // D depends on B and C, both depend on A
+    const tasks = [
+      createTask("D", "medium", ["B", "C"]),
+      createTask("B", "high", ["A"]),
+      createTask("C", "low", ["A"]),
+      createTask("A", "medium"),
+    ];
+    const result = topologicalSort(tasks);
+    // A must come first, D must come last
+    expect(result[0]!.id).toBe("A");
+    expect(result[3]!.id).toBe("D");
+  });
+});
+
+describe("wouldCreateCycle", () => {
+  test("returns false for valid dependency", () => {
+    const tasks = [createTask("A"), createTask("B")];
+    // Adding B blocked_by A should not create cycle
+    expect(wouldCreateCycle(tasks, "B", "A")).toBe(false);
+  });
+
+  test("returns true for direct cycle", () => {
+    const tasks = [createTask("A", "medium", ["B"]), createTask("B")];
+    // B is already blocking A, so A blocking B would create cycle
+    expect(wouldCreateCycle(tasks, "B", "A")).toBe(true);
+  });
+
+  test("returns true for indirect cycle", () => {
+    const tasks = [
+      createTask("A", "medium", ["B"]),
+      createTask("B", "medium", ["C"]),
+      createTask("C"),
+    ];
+    // A <- B <- C, adding C <- A would create cycle
+    expect(wouldCreateCycle(tasks, "C", "A")).toBe(true);
+  });
+});
+
+describe("findDependents", () => {
+  test("returns empty for task with no dependents", () => {
+    const tasks = [createTask("A"), createTask("B")];
+    const result = findDependents(tasks, "A");
+    expect(result).toEqual([]);
+  });
+
+  test("finds direct dependents", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "medium", ["A"]),
+      createTask("C", "medium", ["A"]),
+    ];
+    const result = findDependents(tasks, "A");
+    expect(result.map((t) => t.id).sort()).toEqual(["B", "C"]);
+  });
+
+  test("finds transitive dependents", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "medium", ["A"]),
+      createTask("C", "medium", ["B"]),
+    ];
+    const result = findDependents(tasks, "A");
+    expect(result.map((t) => t.id).sort()).toEqual(["B", "C"]);
+  });
+});
+
+describe("findDependencies", () => {
+  test("returns empty for task with no dependencies", () => {
+    const tasks = [createTask("A"), createTask("B")];
+    const result = findDependencies(tasks, "A");
+    expect(result).toEqual([]);
+  });
+
+  test("finds direct dependencies", () => {
+    const tasks = [createTask("A"), createTask("B"), createTask("C", "medium", ["A", "B"])];
+    const result = findDependencies(tasks, "C");
+    expect(result.map((t) => t.id).sort()).toEqual(["A", "B"]);
+  });
+
+  test("finds transitive dependencies", () => {
+    const tasks = [
+      createTask("A"),
+      createTask("B", "medium", ["A"]),
+      createTask("C", "medium", ["B"]),
+    ];
+    const result = findDependencies(tasks, "C");
+    expect(result.map((t) => t.id).sort()).toEqual(["A", "B"]);
+  });
+});

package/src/algorithms/topological-sort.ts

@@ -115,20 +115,13 @@ export function topologicalSort(tasks: Task[]): Task[] {
 /**
  * Detect if adding a dependency would create a cycle
  */
-export function wouldCreateCycle(
-  tasks: Task[],
-  fromId: string,
-  toId: string
-): boolean {
+export function wouldCreateCycle(tasks: Task[], fromId: string, toId: string): boolean {
   // Create a temporary task list with the new dependency
   const tempTasks = tasks.map((t) => {
     if (t.id === fromId) {
       return {
         ...t,
-        dependencies: [
-          ...(t.dependencies ?? []),
-          { taskId: toId, type: "blocked_by" as const },
-        ],
+        dependencies: [...(t.dependencies ?? []), { taskId: toId, type: "blocked_by" as const }],
       };
     }
     return t;
@@ -173,7 +166,10 @@ export function buildDependencyIndices(tasks: Task[]): {
       .map((d) => d.taskId);
 
     // Store direct dependencies for this task
-    dependenciesIndex.set(task.id, deps.filter((depId) => taskMap.has(depId)));
+    dependenciesIndex.set(
+      task.id,
+      deps.filter((depId) => taskMap.has(depId))
+    );
 
     // Update dependents index (reverse lookup)
     for (const depId of deps) {

package/src/schemas/index.ts

@@ -19,21 +19,10 @@ export {
 } from "./task.js";
 
 // View schemas
-export {
-  SmartViewFilter,
-  SortField,
-  SortOrder,
-  SmartView,
-  BuiltInView,
-} from "./view.js";
+export { SmartViewFilter, SortField, SortOrder, SmartView, BuiltInView } from "./view.js";
 
 // Inbox schemas
-export {
-  InboxStatus,
-  InboxItem,
-  InboxCreateInput,
-  InboxUpdateInput,
-} from "./inbox.js";
+export { InboxStatus, InboxItem, InboxCreateInput, InboxUpdateInput } from "./inbox.js";
 
 // Response format schemas (token optimization)
 export {

package/src/schemas/response-format.ts

@@ -129,9 +129,9 @@ export interface DashboardPriorityBreakdown {
 
 // Dependency metrics
 export interface DashboardDependencyMetrics {
-  ready: number;    // No dependencies or all satisfied
-  blocked: number;  // Has unsatisfied dependencies
-  noDeps: number;   // Tasks with no dependencies
+  ready: number; // No dependencies or all satisfied
+  blocked: number; // Has unsatisfied dependencies
+  noDeps: number; // Tasks with no dependencies
 }
 
 // Next task recommendation
@@ -139,12 +139,12 @@ export interface DashboardNextTask {
   id: string;
   title: string;
   priority: string;
-  reason: string;   // Why this task is recommended
+  reason: string; // Why this task is recommended
 }
 
 // Critical path info
 export interface DashboardCriticalPath {
-  length: number;    // Total duration in minutes
+  length: number; // Total duration in minutes
   taskCount: number; // Number of tasks on critical path
 }
 
@@ -162,7 +162,7 @@ export interface DashboardStatusBreakdown {
 export interface DashboardSubtaskProgress {
   completed: number;
   total: number;
-  pct: number;       // 0-100
+  pct: number; // 0-100
   inProgress: number;
   pending: number;
   blocked: number;

package/src/schemas/response-schema.test.ts

@@ -0,0 +1,314 @@
+import { describe, expect, it } from "bun:test";
+import {
+  ResponseType,
+  ResponsePriority,
+  ResponseOption,
+  QuestionResponse,
+  SuggestionResponse,
+  ConfirmationResponse,
+  GenerateResponseInput,
+} from "./response-schema.js";
+
+describe("Response Schema", () => {
+  describe("ResponseType", () => {
+    it("should accept valid response types", () => {
+      expect(() => ResponseType.parse("question")).not.toThrow();
+      expect(() => ResponseType.parse("suggestion")).not.toThrow();
+      expect(() => ResponseType.parse("confirmation")).not.toThrow();
+    });
+
+    it("should reject invalid response types", () => {
+      expect(() => ResponseType.parse("invalid")).toThrow();
+      expect(() => ResponseType.parse("ask")).toThrow();
+    });
+  });
+
+  describe("ResponsePriority", () => {
+    it("should accept valid priority levels", () => {
+      expect(() => ResponsePriority.parse("low")).not.toThrow();
+      expect(() => ResponsePriority.parse("medium")).not.toThrow();
+      expect(() => ResponsePriority.parse("high")).not.toThrow();
+      expect(() => ResponsePriority.parse("critical")).not.toThrow();
+    });
+
+    it("should reject invalid priority levels", () => {
+      expect(() => ResponsePriority.parse("urgent")).toThrow();
+      expect(() => ResponsePriority.parse("normal")).toThrow();
+    });
+  });
+
+  describe("ResponseOption", () => {
+    it("should validate option with all fields", () => {
+      const option = {
+        label: "High Priority",
+        value: "high",
+        description: "For urgent tasks",
+      };
+
+      expect(() => ResponseOption.parse(option)).not.toThrow();
+      const parsed = ResponseOption.parse(option);
+      expect(parsed.label).toBe("High Priority");
+      expect(parsed.value).toBe("high");
+      expect(parsed.description).toBe("For urgent tasks");
+    });
+
+    it("should validate option without description", () => {
+      const option = {
+        label: "Low Priority",
+        value: "low",
+      };
+
+      expect(() => ResponseOption.parse(option)).not.toThrow();
+      const parsed = ResponseOption.parse(option);
+      expect(parsed.label).toBe("Low Priority");
+      expect(parsed.value).toBe("low");
+      expect(parsed.description).toBeUndefined();
+    });
+
+    it("should reject option without required fields", () => {
+      expect(() => ResponseOption.parse({ label: "Test" })).toThrow();
+      expect(() => ResponseOption.parse({ value: "test" })).toThrow();
+      expect(() => ResponseOption.parse({})).toThrow();
+    });
+  });
+
+  describe("QuestionResponse", () => {
+    it("should validate question with all fields", () => {
+      const question = {
+        type: "question" as const,
+        message: "What should we do?",
+        context: "Need clarification on approach",
+        priority: "high" as const,
+        options: [
+          { label: "Option A", value: "a" },
+          { label: "Option B", value: "b" },
+        ],
+        defaultOption: "a",
+      };
+
+      expect(() => QuestionResponse.parse(question)).not.toThrow();
+      const parsed = QuestionResponse.parse(question);
+      expect(parsed.type).toBe("question");
+      expect(parsed.message).toBe("What should we do?");
+      expect(parsed.options).toHaveLength(2);
+      expect(parsed.defaultOption).toBe("a");
+    });
+
+    it("should validate question with minimal fields", () => {
+      const question = {
+        type: "question" as const,
+        message: "Proceed?",
+      };
+
+      expect(() => QuestionResponse.parse(question)).not.toThrow();
+      const parsed = QuestionResponse.parse(question);
+      expect(parsed.type).toBe("question");
+      expect(parsed.message).toBe("Proceed?");
+      expect(parsed.context).toBeUndefined();
+      expect(parsed.options).toBeUndefined();
+    });
+
+    it("should reject question without message", () => {
+      expect(() => QuestionResponse.parse({ type: "question" })).toThrow();
+    });
+
+    it("should reject question with wrong type", () => {
+      expect(() =>
+        QuestionResponse.parse({
+          type: "suggestion",
+          message: "Test",
+        })
+      ).toThrow();
+    });
+  });
+
+  describe("SuggestionResponse", () => {
+    it("should validate suggestion with all fields", () => {
+      const suggestion = {
+        type: "suggestion" as const,
+        message: "Consider breaking down this task",
+        context: "Task is complex",
+        priority: "medium" as const,
+        options: [
+          { label: "3 subtasks", value: "sub_3" },
+          { label: "5 subtasks", value: "sub_5" },
+        ],
+        reasoning: "Based on complexity analysis",
+      };
+
+      expect(() => SuggestionResponse.parse(suggestion)).not.toThrow();
+      const parsed = SuggestionResponse.parse(suggestion);
+      expect(parsed.type).toBe("suggestion");
+      expect(parsed.options).toHaveLength(2);
+      expect(parsed.reasoning).toBe("Based on complexity analysis");
+    });
+
+    it("should validate suggestion with minimal fields", () => {
+      const suggestion = {
+        type: "suggestion" as const,
+        message: "Try this",
+        options: [{ label: "Do it", value: "yes" }],
+      };
+
+      expect(() => SuggestionResponse.parse(suggestion)).not.toThrow();
+      const parsed = SuggestionResponse.parse(suggestion);
+      expect(parsed.options).toHaveLength(1);
+    });
+
+    it("should reject suggestion without options", () => {
+      expect(() =>
+        SuggestionResponse.parse({
+          type: "suggestion",
+          message: "Test",
+        })
+      ).toThrow();
+    });
+
+    it("should reject suggestion with empty options array", () => {
+      expect(() =>
+        SuggestionResponse.parse({
+          type: "suggestion",
+          message: "Test",
+          options: [],
+        })
+      ).toThrow();
+    });
+  });
+
+  describe("ConfirmationResponse", () => {
+    it("should validate confirmation with all fields", () => {
+      const confirmation = {
+        type: "confirmation" as const,
+        message: "Are you sure?",
+        action: "Delete all completed tasks",
+        context: "This operation is irreversible",
+        priority: "critical" as const,
+        consequences: ["10 tasks will be removed", "Cannot be undone"],
+        defaultConfirm: false,
+      };
+
+      expect(() => ConfirmationResponse.parse(confirmation)).not.toThrow();
+      const parsed = ConfirmationResponse.parse(confirmation);
+      expect(parsed.type).toBe("confirmation");
+      expect(parsed.action).toBe("Delete all completed tasks");
+      expect(parsed.consequences).toHaveLength(2);
+      expect(parsed.defaultConfirm).toBe(false);
+    });
+
+    it("should validate confirmation with minimal fields", () => {
+      const confirmation = {
+        type: "confirmation" as const,
+        message: "Delete this?",
+        action: "Delete task",
+      };
+
+      expect(() => ConfirmationResponse.parse(confirmation)).not.toThrow();
+      const parsed = ConfirmationResponse.parse(confirmation);
+      expect(parsed.action).toBe("Delete task");
+      expect(parsed.consequences).toBeUndefined();
+    });
+
+    it("should reject confirmation without action", () => {
+      expect(() =>
+        ConfirmationResponse.parse({
+          type: "confirmation",
+          message: "Confirm?",
+        })
+      ).toThrow();
+    });
+
+    it("should reject confirmation without message", () => {
+      expect(() =>
+        ConfirmationResponse.parse({
+          type: "confirmation",
+          action: "Do something",
+        })
+      ).toThrow();
+    });
+  });
+
+  describe("GenerateResponseInput", () => {
+    it("should validate input for question type", () => {
+      const input = {
+        type: "question" as const,
+        message: "What to do?",
+        options: [{ label: "Yes", value: "yes" }],
+        defaultOption: "yes",
+      };
+
+      expect(() => GenerateResponseInput.parse(input)).not.toThrow();
+      const parsed = GenerateResponseInput.parse(input);
+      expect(parsed.type).toBe("question");
+    });
+
+    it("should validate input for suggestion type", () => {
+      const input = {
+        type: "suggestion" as const,
+        message: "Try this",
+        options: [{ label: "Option", value: "opt" }],
+        reasoning: "Because reasons",
+      };
+
+      expect(() => GenerateResponseInput.parse(input)).not.toThrow();
+    });
+
+    it("should validate input for confirmation type", () => {
+      const input = {
+        type: "confirmation" as const,
+        message: "Sure?",
+        action: "Delete",
+        consequences: ["Gone forever"],
+        defaultConfirm: false,
+      };
+
+      expect(() => GenerateResponseInput.parse(input)).not.toThrow();
+    });
+
+    it("should use default priority of medium", () => {
+      const input = {
+        type: "question" as const,
+        message: "Test?",
+      };
+
+      const parsed = GenerateResponseInput.parse(input);
+      expect(parsed.priority).toBe("medium");
+    });
+
+    it("should allow custom priority", () => {
+      const input = {
+        type: "question" as const,
+        message: "Test?",
+        priority: "critical" as const,
+      };
+
+      const parsed = GenerateResponseInput.parse(input);
+      expect(parsed.priority).toBe("critical");
+    });
+  });
+
+  describe("Type discrimination", () => {
+    it("should differentiate response types at compile time", () => {
+      const question: QuestionResponse = {
+        type: "question",
+        message: "Test",
+      };
+
+      const suggestion: SuggestionResponse = {
+        type: "suggestion",
+        message: "Test",
+        options: [{ label: "A", value: "a" }],
+      };
+
+      const confirmation: ConfirmationResponse = {
+        type: "confirmation",
+        message: "Test",
+        action: "Do it",
+      };
+
+      // TypeScript should allow this
+      expect(question.type).toBe("question");
+      expect(suggestion.type).toBe("suggestion");
+      expect(confirmation.type).toBe("confirmation");
+    });
+  });
+});

package/src/schemas/response-schema.ts

@@ -28,26 +28,27 @@ const BaseResponse = z.object({
   type: ResponseType.describe("Type of response: question, suggestion, or confirmation"),
   message: z.string().describe("Main message to display to user"),
   context: z.string().optional().describe("Additional context or explanation"),
-  priority: ResponsePriority.optional().describe("Urgency/importance of response (default: medium)"),
+  priority: ResponsePriority.optional().describe(
+    "Urgency/importance of response (default: medium)"
+  ),
 });
 
 // Question response - for clarification
 export const QuestionResponse = BaseResponse.extend({
   type: z.literal("question"),
-  options: z.array(ResponseOption).optional()
+  options: z
+    .array(ResponseOption)
+    .optional()
     .describe("Multiple choice options (omit for free-form answer)"),
-  defaultOption: z.string().optional()
-    .describe("Default option value if user provides no input"),
+  defaultOption: z.string().optional().describe("Default option value if user provides no input"),
 });
 export type QuestionResponse = z.infer<typeof QuestionResponse>;
 
 // Suggestion response - for recommendations
 export const SuggestionResponse = BaseResponse.extend({
   type: z.literal("suggestion"),
-  options: z.array(ResponseOption).min(1)
-    .describe("Suggested options for user to choose from"),
-  reasoning: z.string().optional()
-    .describe("Explanation of why these suggestions were made"),
+  options: z.array(ResponseOption).min(1).describe("Suggested options for user to choose from"),
+  reasoning: z.string().optional().describe("Explanation of why these suggestions were made"),
 });
 export type SuggestionResponse = z.infer<typeof SuggestionResponse>;
 
@@ -55,9 +56,13 @@ export type SuggestionResponse = z.infer<typeof SuggestionResponse>;
 export const ConfirmationResponse = BaseResponse.extend({
   type: z.literal("confirmation"),
   action: z.string().describe("Action that will be taken if confirmed"),
-  consequences: z.array(z.string()).optional()
+  consequences: z
+    .array(z.string())
+    .optional()
     .describe("List of effects or changes that will occur"),
-  defaultConfirm: z.boolean().optional()
+  defaultConfirm: z
+    .boolean()
+    .optional()
     .describe("Default choice if user provides no input (default: false)"),
 });
 export type ConfirmationResponse = z.infer<typeof ConfirmationResponse>;
@@ -74,19 +79,19 @@ export type AgentResponse = z.infer<typeof AgentResponse>;
 export const GenerateResponseInput = z.object({
   type: ResponseType.describe("Type of response to generate"),
   message: z.string().describe("Main message"),
-  options: z.array(ResponseOption).optional()
-    .describe("Options for question/suggestion types"),
+  options: z.array(ResponseOption).optional().describe("Options for question/suggestion types"),
   context: z.string().optional(),
   priority: ResponsePriority.optional().default("medium"),
-  action: z.string().optional()
-    .describe("Action description (for confirmation type)"),
-  consequences: z.array(z.string()).optional()
+  action: z.string().optional().describe("Action description (for confirmation type)"),
+  consequences: z
+    .array(z.string())
+    .optional()
     .describe("Consequences list (for confirmation type)"),
-  reasoning: z.string().optional()
-    .describe("Reasoning explanation (for suggestion type)"),
-  defaultOption: z.string().optional()
-    .describe("Default option value (for question type)"),
-  defaultConfirm: z.boolean().optional()
+  reasoning: z.string().optional().describe("Reasoning explanation (for suggestion type)"),
+  defaultOption: z.string().optional().describe("Default option value (for question type)"),
+  defaultConfirm: z
+    .boolean()
+    .optional()
     .describe("Default confirmation choice (for confirmation type)"),
 });
 export type GenerateResponseInput = z.infer<typeof GenerateResponseInput>;