@task-mcp/shared 1.0.6 → 1.0.8

package/src/schemas/response-schema.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+/**
+ * Response Schema
+ *
+ * Standardized formats for AI agents to ask questions, make suggestions,
+ * or request confirmation from users.
+ */
+
+// Response types
+export const ResponseType = z.enum(["question", "suggestion", "confirmation"]);
+export type ResponseType = z.infer<typeof ResponseType>;
+
+// Priority level for responses
+export const ResponsePriority = z.enum(["low", "medium", "high", "critical"]);
+export type ResponsePriority = z.infer<typeof ResponsePriority>;
+
+// Option for multiple choice responses
+export const ResponseOption = z.object({
+  label: z.string().describe("Display text for the option"),
+  value: z.string().describe("Value to return when selected"),
+  description: z.string().optional().describe("Additional explanation"),
+});
+export type ResponseOption = z.infer<typeof ResponseOption>;
+
+// Base response schema
+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)"),
+});
+
+// Question response - for clarification
+export const QuestionResponse = BaseResponse.extend({
+  type: z.literal("question"),
+  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"),
+});
+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"),
+});
+export type SuggestionResponse = z.infer<typeof SuggestionResponse>;
+
+// Confirmation response - for explicit approval
+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()
+    .describe("List of effects or changes that will occur"),
+  defaultConfirm: z.boolean().optional()
+    .describe("Default choice if user provides no input (default: false)"),
+});
+export type ConfirmationResponse = z.infer<typeof ConfirmationResponse>;
+
+// Union type for all response types
+export const AgentResponse = z.discriminatedUnion("type", [
+  QuestionResponse,
+  SuggestionResponse,
+  ConfirmationResponse,
+]);
+export type AgentResponse = z.infer<typeof AgentResponse>;
+
+// Input schema for generating responses
+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"),
+  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()
+    .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()
+    .describe("Default confirmation choice (for confirmation type)"),
+});
+export type GenerateResponseInput = z.infer<typeof GenerateResponseInput>;

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>;