@task-mcp/shared 1.0.6 → 1.0.8

package/src/schemas/inbox.ts

@@ -1,32 +1,32 @@
-import { type } from "arktype";
+import { z } from "zod";
 
 // Inbox item status
-export const InboxStatus = type("'pending' | 'promoted' | 'discarded'");
-export type InboxStatus = typeof InboxStatus.infer;
+export const InboxStatus = z.enum(["pending", "promoted", "discarded"]);
+export type InboxStatus = z.infer<typeof InboxStatus>;
 
 // Inbox item schema - lightweight idea/memo capture
-export const InboxItem = type({
-  id: "string",
-  content: "string", // The memo/idea content
-  capturedAt: "string", // ISO timestamp
-  "source?": "string", // Origin: 'cli', 'mcp', 'api', etc.
-  "tags?": "string[]", // Simple tags for organization
-  "promotedToTaskId?": "string", // Task ID if promoted
+export const InboxItem = z.object({
+  id: z.string(),
+  content: z.string(), // The memo/idea content
+  capturedAt: z.string(), // ISO timestamp
+  source: z.string().optional(), // Origin: 'cli', 'mcp', 'api', etc.
+  tags: z.array(z.string()).optional(), // Simple tags for organization
+  promotedToTaskId: z.string().optional(), // Task ID if promoted
   status: InboxStatus,
 });
-export type InboxItem = typeof InboxItem.infer;
+export type InboxItem = z.infer<typeof InboxItem>;
 
 // Inbox item creation input (minimal)
-export const InboxCreateInput = type({
-  content: "string",
-  "source?": "string",
-  "tags?": "string[]",
+export const InboxCreateInput = z.object({
+  content: z.string(),
+  source: z.string().optional(),
+  tags: z.array(z.string()).optional(),
 });
-export type InboxCreateInput = typeof InboxCreateInput.infer;
+export type InboxCreateInput = z.infer<typeof InboxCreateInput>;
 
 // Inbox item update input
-export const InboxUpdateInput = type({
-  "content?": "string",
-  "tags?": "string[]",
+export const InboxUpdateInput = z.object({
+  content: z.string().optional(),
+  tags: z.array(z.string()).optional(),
 });
-export type InboxUpdateInput = typeof InboxUpdateInput.infer;
+export type InboxUpdateInput = z.infer<typeof InboxUpdateInput>;

package/src/schemas/index.ts

@@ -58,4 +58,27 @@ export {
   type InboxPreview,
   type CriticalPathSummary,
   type BottleneckSummary,
+  // Dashboard types
+  type DashboardProgress,
+  type DashboardPriorityBreakdown,
+  type DashboardDependencyMetrics,
+  type DashboardNextTask,
+  type DashboardCriticalPath,
+  type DashboardStatusBreakdown,
+  type DashboardSubtaskProgress,
+  type DashboardDependencyStats,
+  type DashboardConcise,
+  type DashboardStandard,
 } from "./response-format.js";
+
+// Response schema (agent interaction)
+export {
+  ResponseType,
+  ResponsePriority,
+  ResponseOption,
+  QuestionResponse,
+  SuggestionResponse,
+  ConfirmationResponse,
+  AgentResponse,
+  GenerateResponseInput,
+} from "./response-schema.js";

package/src/schemas/project.ts

@@ -1,62 +1,68 @@
-import { type } from "arktype";
+import { z } from "zod";
 import { Priority } from "./task.js";
 
 // Project status
-export const ProjectStatus = type(
-  "'active' | 'on_hold' | 'completed' | 'archived'"
-);
-export type ProjectStatus = typeof ProjectStatus.infer;
+export const ProjectStatus = z.enum([
+  "active",
+  "on_hold",
+  "completed",
+  "archived",
+]);
+export type ProjectStatus = z.infer<typeof ProjectStatus>;
 
 // Context definition
-export const Context = type({
-  name: "string",
-  "color?": "string", // hex color
-  "description?": "string",
+export const Context = z.object({
+  name: z.string(),
+  color: z.string().optional(), // hex color
+  description: z.string().optional(),
 });
-export type Context = typeof Context.infer;
+export type Context = z.infer<typeof Context>;
 
 // Project schema
-export const Project = type({
-  id: "string",
-  name: "string",
-  "description?": "string",
+export const Project = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
   status: ProjectStatus,
 
   // Project-level settings
-  "defaultPriority?": Priority,
-  "contexts?": Context.array(),
+  defaultPriority: Priority.optional(),
+  contexts: z.array(Context).optional(),
 
   // Metadata
-  createdAt: "string",
-  updatedAt: "string",
-  "targetDate?": "string",
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  targetDate: z.string().optional(),
+  sortOrder: z.number().optional(), // User-defined display order (auto-assigned if not specified)
 
   // Computed stats
-  "completionPercentage?": "number",
-  "criticalPathLength?": "number", // Total minutes on critical path
-  "blockedTaskCount?": "number",
-  "totalTasks?": "number",
-  "completedTasks?": "number",
+  completionPercentage: z.number().optional(),
+  criticalPathLength: z.number().optional(), // Total minutes on critical path
+  blockedTaskCount: z.number().optional(),
+  totalTasks: z.number().optional(),
+  completedTasks: z.number().optional(),
 });
-export type Project = typeof Project.infer;
+export type Project = z.infer<typeof Project>;
 
 // Project creation input
-export const ProjectCreateInput = type({
-  name: "string",
-  "description?": "string",
-  "defaultPriority?": Priority,
-  "contexts?": Context.array(),
-  "targetDate?": "string",
+export const ProjectCreateInput = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  defaultPriority: Priority.optional(),
+  contexts: z.array(Context).optional(),
+  targetDate: z.string().optional(),
+  sortOrder: z.number().optional(), // Auto-assigned if not specified
 });
-export type ProjectCreateInput = typeof ProjectCreateInput.infer;
+export type ProjectCreateInput = z.infer<typeof ProjectCreateInput>;
 
 // Project update input
-export const ProjectUpdateInput = type({
-  "name?": "string",
-  "description?": "string",
-  "status?": ProjectStatus,
-  "defaultPriority?": Priority,
-  "contexts?": Context.array(),
-  "targetDate?": "string",
+export const ProjectUpdateInput = z.object({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  status: ProjectStatus.optional(),
+  defaultPriority: Priority.optional(),
+  contexts: z.array(Context).optional(),
+  targetDate: z.string().optional(),
+  sortOrder: z.number().optional(),
 });
-export type ProjectUpdateInput = typeof ProjectUpdateInput.infer;
+export type ProjectUpdateInput = z.infer<typeof ProjectUpdateInput>;

package/src/schemas/response-format.ts

@@ -1,4 +1,4 @@
-import { type } from "arktype";
+import { z } from "zod";
 
 /**
  * Response Format Schema
@@ -12,8 +12,8 @@ import { type } from "arktype";
  */
 
 // Response format options
-export const ResponseFormat = type("'concise' | 'standard' | 'detailed'");
-export type ResponseFormat = typeof ResponseFormat.infer;
+export const ResponseFormat = z.enum(["concise", "standard", "detailed"]);
+export type ResponseFormat = z.infer<typeof ResponseFormat>;
 
 // Default limits for pagination
 export const DEFAULT_LIMIT = 20;
@@ -106,3 +106,99 @@ export interface BottleneckSummary {
   title: string;
   blockedCount: number;
 }
+
+/**
+ * Dashboard response types - project_dashboard tool
+ *
+ * Provides unified project overview with progress, priority breakdown,
+ * dependency metrics, and next task recommendation.
+ */
+
+// Progress metrics
+export interface DashboardProgress {
+  completed: number;
+  total: number;
+  pct: number; // 0-100
+}
+
+// Priority breakdown
+export interface DashboardPriorityBreakdown {
+  critical: number;
+  high: number;
+  medium: number;
+  low: number;
+}
+
+// Dependency metrics
+export interface DashboardDependencyMetrics {
+  ready: number;    // No dependencies or all satisfied
+  blocked: number;  // Has unsatisfied dependencies
+  noDeps: number;   // Tasks with no dependencies
+}
+
+// Next task recommendation
+export interface DashboardNextTask {
+  id: string;
+  title: string;
+  priority: string;
+  reason: string;   // Why this task is recommended
+}
+
+// Critical path info
+export interface DashboardCriticalPath {
+  length: number;    // Total duration in minutes
+  taskCount: number; // Number of tasks on critical path
+}
+
+// Status breakdown (TaskMaster-style)
+export interface DashboardStatusBreakdown {
+  done: number;
+  inProgress: number;
+  pending: number;
+  blocked: number;
+  deferred: number;
+  cancelled: number;
+}
+
+// Subtask progress metrics (TaskMaster-style)
+export interface DashboardSubtaskProgress {
+  completed: number;
+  total: number;
+  pct: number;       // 0-100
+  inProgress: number;
+  pending: number;
+  blocked: number;
+}
+
+// Dependency statistics (TaskMaster-style)
+export interface DashboardDependencyStats {
+  mostDependedOn?: {
+    taskId: string;
+    title: string;
+    dependentCount: number; // How many tasks depend on this
+  };
+  avgDepsPerTask: number; // Average number of dependencies per task
+}
+
+// Concise format (~100 tokens) - essential metrics only
+export interface DashboardConcise {
+  id: string;
+  name: string;
+  progress: DashboardProgress;
+  statusBreakdown: DashboardStatusBreakdown;
+  subtaskProgress?: DashboardSubtaskProgress;
+  priority: DashboardPriorityBreakdown;
+  dependency: DashboardDependencyMetrics;
+  dependencyStats: DashboardDependencyStats;
+  nextTask?: DashboardNextTask;
+}
+
+// Standard format (~300 tokens) - includes tasks and critical path
+export interface DashboardStandard extends DashboardConcise {
+  projectStatus: string;
+  targetDate?: string;
+  criticalPath?: DashboardCriticalPath;
+  tasks: TaskSummary[];
+}
+
+// Detailed format - human-readable markdown (use string output)

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");
+    });
+  });
+});