@task-mcp/shared 1.0.6 → 1.0.7

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/project.ts

@@ -1,62 +1,65 @@
-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(),
 
   // 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(),
 });
-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(),
 });
-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;

package/src/schemas/task.ts

@@ -1,166 +1,184 @@
-import { type } from "arktype";
+import { z } from "zod";
 
 // Priority levels
-export const Priority = type("'critical' | 'high' | 'medium' | 'low'");
-export type Priority = typeof Priority.infer;
+export const Priority = z.enum(["critical", "high", "medium", "low"]);
+export type Priority = z.infer<typeof Priority>;
 
 // Task status with clear state machine
-export const TaskStatus = type(
-  "'pending' | 'in_progress' | 'blocked' | 'completed' | 'cancelled'"
-);
-export type TaskStatus = typeof TaskStatus.infer;
+export const TaskStatus = z.enum([
+  "pending",
+  "in_progress",
+  "blocked",
+  "completed",
+  "cancelled",
+]);
+export type TaskStatus = z.infer<typeof TaskStatus>;
 
 // Dependency relationship types
-export const DependencyType = type(
-  "'blocks' | 'blocked_by' | 'related'"
-);
-export type DependencyType = typeof DependencyType.infer;
+export const DependencyType = z.enum(["blocks", "blocked_by", "related"]);
+export type DependencyType = z.infer<typeof DependencyType>;
 
 // A single dependency link
-export const Dependency = type({
-  taskId: "string",
+export const Dependency = z.object({
+  taskId: z.string(),
   type: DependencyType,
-  "reason?": "string",
+  reason: z.string().optional(),
 });
-export type Dependency = typeof Dependency.infer;
+export type Dependency = z.infer<typeof Dependency>;
 
 // Time estimation
-export const TimeEstimate = type({
-  "optimistic?": "number", // minutes
-  "expected?": "number", // minutes
-  "pessimistic?": "number", // minutes
-  "confidence?": "'low' | 'medium' | 'high'",
+export const TimeEstimate = z.object({
+  optimistic: z.number().optional(), // minutes
+  expected: z.number().optional(), // minutes
+  pessimistic: z.number().optional(), // minutes
+  confidence: z.enum(["low", "medium", "high"]).optional(),
 });
-export type TimeEstimate = typeof TimeEstimate.infer;
+export type TimeEstimate = z.infer<typeof TimeEstimate>;
 
 // Recurrence pattern
-export const Recurrence = type({
-  pattern: "'daily' | 'weekly' | 'monthly' | 'after_completion'",
-  "interval?": "number", // every N days/weeks/months
-  "daysOfWeek?": "number[]", // 0-6 for weekly
-  "endDate?": "string",
+export const Recurrence = z.object({
+  pattern: z.enum(["daily", "weekly", "monthly", "after_completion"]),
+  interval: z.number().optional(), // every N days/weeks/months
+  daysOfWeek: z.array(z.number()).optional(), // 0-6 for weekly
+  endDate: z.string().optional(),
 });
-export type Recurrence = typeof Recurrence.infer;
+export type Recurrence = z.infer<typeof Recurrence>;
 
 // Complexity factors that contribute to task difficulty
-export const ComplexityFactor = type(
-  "'cross_cutting' | 'state_management' | 'error_handling' | 'performance' | 'security' | 'external_dependency' | 'data_migration' | 'breaking_change' | 'unclear_requirements' | 'coordination'"
-);
-export type ComplexityFactor = typeof ComplexityFactor.infer;
+export const ComplexityFactor = z.enum([
+  "cross_cutting",
+  "state_management",
+  "error_handling",
+  "performance",
+  "security",
+  "external_dependency",
+  "data_migration",
+  "breaking_change",
+  "unclear_requirements",
+  "coordination",
+]);
+export type ComplexityFactor = z.infer<typeof ComplexityFactor>;
 
 // Complexity analysis result (populated by Claude)
-export const ComplexityAnalysis = type({
-  "score?": "number", // 1-10 complexity score
-  "factors?": ComplexityFactor.array(),
-  "suggestedSubtasks?": "number", // 0-10 recommended subtask count
-  "rationale?": "string",
-  "analyzedAt?": "string",
+export const ComplexityAnalysis = z.object({
+  score: z.number().optional(), // 1-10 complexity score
+  factors: z.array(ComplexityFactor).optional(),
+  suggestedSubtasks: z.number().optional(), // 0-10 recommended subtask count
+  rationale: z.string().optional(),
+  analyzedAt: z.string().optional(),
 });
-export type ComplexityAnalysis = typeof ComplexityAnalysis.infer;
+export type ComplexityAnalysis = z.infer<typeof ComplexityAnalysis>;
 
 // Tech area categories for ordering
-export const TechArea = type(
-  "'schema' | 'backend' | 'frontend' | 'infra' | 'devops' | 'test' | 'docs' | 'refactor'"
-);
-export type TechArea = typeof TechArea.infer;
+export const TechArea = z.enum([
+  "schema",
+  "backend",
+  "frontend",
+  "infra",
+  "devops",
+  "test",
+  "docs",
+  "refactor",
+]);
+export type TechArea = z.infer<typeof TechArea>;
 
 // Risk level for changes
-export const RiskLevel = type("'low' | 'medium' | 'high' | 'critical'");
-export type RiskLevel = typeof RiskLevel.infer;
+export const RiskLevel = z.enum(["low", "medium", "high", "critical"]);
+export type RiskLevel = z.infer<typeof RiskLevel>;
 
 // Tech stack analysis result (populated by Claude)
-export const TechStackAnalysis = type({
-  "areas?": TechArea.array(),
-  "hasBreakingChange?": "boolean",
-  "riskLevel?": RiskLevel,
-  "affectedComponents?": "string[]",
-  "rationale?": "string",
-  "analyzedAt?": "string",
+export const TechStackAnalysis = z.object({
+  areas: z.array(TechArea).optional(),
+  hasBreakingChange: z.boolean().optional(),
+  riskLevel: RiskLevel.optional(),
+  affectedComponents: z.array(z.string()).optional(),
+  rationale: z.string().optional(),
+  analyzedAt: z.string().optional(),
 });
-export type TechStackAnalysis = typeof TechStackAnalysis.infer;
+export type TechStackAnalysis = z.infer<typeof TechStackAnalysis>;
 
 // Core Task schema
-export const Task = type({
-  id: "string",
-  title: "string",
-  "description?": "string",
+export const Task = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
   status: TaskStatus,
   priority: Priority,
-  projectId: "string",
+  projectId: z.string(),
 
   // Hierarchy (subtask support)
-  "parentId?": "string", // Parent task ID for subtasks
-  "level?": "number", // Hierarchy depth (0=root, 1=subtask, 2=sub-subtask, max 3)
+  parentId: z.string().nullable().optional(), // Parent task ID for subtasks (null to unlink)
+  level: z.number().optional(), // Hierarchy depth (0=root, 1=subtask, 2=sub-subtask, max 3)
 
   // Dependencies
-  "dependencies?": Dependency.array(),
+  dependencies: z.array(Dependency).optional(),
 
   // Time tracking
-  "estimate?": TimeEstimate,
-  "actualMinutes?": "number",
-  "dueDate?": "string", // ISO date string
-  "startDate?": "string", // When task can start
-  "startedAt?": "string",
-  "completedAt?": "string",
+  estimate: TimeEstimate.optional(),
+  actualMinutes: z.number().optional(),
+  dueDate: z.string().optional(), // ISO date string
+  startDate: z.string().optional(), // When task can start
+  startedAt: z.string().optional(),
+  completedAt: z.string().optional(),
 
   // Organization
-  "contexts?": "string[]", // e.g., ["focus", "review"]
-  "tags?": "string[]",
+  contexts: z.array(z.string()).optional(), // e.g., ["focus", "review"]
+  tags: z.array(z.string()).optional(),
 
   // Recurrence
-  "recurrence?": Recurrence,
+  recurrence: Recurrence.optional(),
 
   // Metadata
-  createdAt: "string",
-  updatedAt: "string",
+  createdAt: z.string(),
+  updatedAt: z.string(),
 
   // Computed fields (populated at runtime)
-  "criticalPath?": "boolean",
-  "slack?": "number", // Minutes of slack time
-  "earliestStart?": "number", // Minutes from project start
-  "latestStart?": "number",
+  criticalPath: z.boolean().optional(),
+  slack: z.number().optional(), // Minutes of slack time
+  earliestStart: z.number().optional(), // Minutes from project start
+  latestStart: z.number().optional(),
 
   // Analysis fields (populated by Claude)
-  "complexity?": ComplexityAnalysis,
-  "techStack?": TechStackAnalysis,
+  complexity: ComplexityAnalysis.optional(),
+  techStack: TechStackAnalysis.optional(),
 });
-export type Task = typeof Task.infer;
+export type Task = z.infer<typeof Task>;
 
 // Task creation input (minimal required fields)
-export const TaskCreateInput = type({
-  title: "string",
-  "description?": "string",
-  "projectId?": "string",
-  "priority?": Priority,
-  "parentId?": "string", // Parent task ID for creating subtasks
-  "dependencies?": Dependency.array(),
-  "estimate?": TimeEstimate,
-  "dueDate?": "string",
-  "startDate?": "string",
-  "contexts?": "string[]",
-  "tags?": "string[]",
-  "recurrence?": Recurrence,
+export const TaskCreateInput = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  projectId: z.string().optional(),
+  priority: Priority.optional(),
+  parentId: z.string().nullable().optional(), // Parent task ID for creating subtasks (null to unlink)
+  dependencies: z.array(Dependency).optional(),
+  estimate: TimeEstimate.optional(),
+  dueDate: z.string().optional(),
+  startDate: z.string().optional(),
+  contexts: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  recurrence: Recurrence.optional(),
 });
-export type TaskCreateInput = typeof TaskCreateInput.infer;
+export type TaskCreateInput = z.infer<typeof TaskCreateInput>;
 
 // Task update input
-export const TaskUpdateInput = type({
-  "title?": "string",
-  "description?": "string",
-  "status?": TaskStatus,
-  "priority?": Priority,
-  "projectId?": "string",
-  "parentId?": "string", // Parent task ID for moving task in hierarchy
-  "dependencies?": Dependency.array(),
-  "estimate?": TimeEstimate,
-  "actualMinutes?": "number",
-  "dueDate?": "string",
-  "startDate?": "string",
-  "contexts?": "string[]",
-  "tags?": "string[]",
-  "recurrence?": Recurrence,
+export const TaskUpdateInput = z.object({
+  title: z.string().optional(),
+  description: z.string().optional(),
+  status: TaskStatus.optional(),
+  priority: Priority.optional(),
+  projectId: z.string().optional(),
+  parentId: z.string().nullable().optional(), // Parent task ID for moving task in hierarchy (null to unlink)
+  dependencies: z.array(Dependency).optional(),
+  estimate: TimeEstimate.optional(),
+  actualMinutes: z.number().optional(),
+  dueDate: z.string().optional(),
+  startDate: z.string().optional(),
+  contexts: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  recurrence: Recurrence.optional(),
   // Analysis fields
-  "complexity?": ComplexityAnalysis,
-  "techStack?": TechStackAnalysis,
+  complexity: ComplexityAnalysis.optional(),
+  techStack: TechStackAnalysis.optional(),
 });
-export type TaskUpdateInput = typeof TaskUpdateInput.infer;
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInput>;

package/src/schemas/view.ts

@@ -1,46 +1,56 @@
-import { type } from "arktype";
+import { z } from "zod";
 import { Priority, TaskStatus } from "./task.js";
 
 // Smart View filter
-export const SmartViewFilter = type({
-  "statuses?": TaskStatus.array(),
-  "priorities?": Priority.array(),
-  "contexts?": "string[]",
-  "tags?": "string[]",
-  "projectIds?": "string[]",
-  "dueBefore?": "string",
-  "dueAfter?": "string",
-  "isBlocked?": "boolean",
-  "isCriticalPath?": "boolean",
-  "hasNoDependencies?": "boolean",
-  "search?": "string", // Search in title/description
+export const SmartViewFilter = z.object({
+  statuses: z.array(TaskStatus).optional(),
+  priorities: z.array(Priority).optional(),
+  contexts: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  projectIds: z.array(z.string()).optional(),
+  dueBefore: z.string().optional(),
+  dueAfter: z.string().optional(),
+  isBlocked: z.boolean().optional(),
+  isCriticalPath: z.boolean().optional(),
+  hasNoDependencies: z.boolean().optional(),
+  search: z.string().optional(), // Search in title/description
 });
-export type SmartViewFilter = typeof SmartViewFilter.infer;
+export type SmartViewFilter = z.infer<typeof SmartViewFilter>;
 
 // Sort options
-export const SortField = type(
-  "'priority' | 'dueDate' | 'createdAt' | 'criticalPath' | 'slack' | 'title'"
-);
-export type SortField = typeof SortField.infer;
+export const SortField = z.enum([
+  "priority",
+  "dueDate",
+  "createdAt",
+  "criticalPath",
+  "slack",
+  "title",
+]);
+export type SortField = z.infer<typeof SortField>;
 
-export const SortOrder = type("'asc' | 'desc'");
-export type SortOrder = typeof SortOrder.infer;
+export const SortOrder = z.enum(["asc", "desc"]);
+export type SortOrder = z.infer<typeof SortOrder>;
 
 // Smart View definition
-export const SmartView = type({
-  id: "string",
-  name: "string",
-  "description?": "string",
+export const SmartView = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
   filter: SmartViewFilter,
-  "sortBy?": SortField,
-  "sortOrder?": SortOrder,
-  createdAt: "string",
-  updatedAt: "string",
+  sortBy: SortField.optional(),
+  sortOrder: SortOrder.optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
 });
-export type SmartView = typeof SmartView.infer;
+export type SmartView = z.infer<typeof SmartView>;
 
 // Built-in view names
-export const BuiltInView = type(
-  "'today' | 'this_week' | 'blocked' | 'critical_path' | 'quick_wins' | 'all'"
-);
-export type BuiltInView = typeof BuiltInView.infer;
+export const BuiltInView = z.enum([
+  "today",
+  "this_week",
+  "blocked",
+  "critical_path",
+  "quick_wins",
+  "all",
+]);
+export type BuiltInView = z.infer<typeof BuiltInView>;