GonMCPtool

Instructions

Implementation Reference

• main.ts:804-834 (registration)

  Registration of the 'taskSearch' MCP tool, including input schema definition and a thin wrapper handler that delegates to TaskManagerTool.searchTasks

  server.tool("taskSearch",
      "根據條件搜索任務",
      {
          filter: z.object({
              status: z.enum([
                  TaskStatus.PENDING,
                  TaskStatus.IN_PROGRESS,
                  TaskStatus.COMPLETED,
                  TaskStatus.CANCELLED
              ]).optional(),
              tags: z.array(z.string()).optional(),
              priority: z.number().optional(),
              dueDateFrom: z.string().optional(),
              dueDateTo: z.string().optional(),
              searchText: z.string().optional()
          })
      },
      async ({ filter }) => {
          try {
              const tasks = await TaskManagerTool.searchTasks(filter);
  
              return {
                  content: [{ type: "text", text: `搜索到 ${tasks.length} 個任務：\n${JSON.stringify(tasks, null, 2)}` }]
              };
          } catch (error) {
              return {
                  content: [{ type: "text", text: `搜索任務失敗: ${error instanceof Error ? error.message : "未知錯誤"}` }]
              };
          }
      }
  );

• tools/taskManagerTool.ts:350-439 (handler)

  Core implementation of task search logic: reads all tasks and filters them based on status, tags, priority, due dates, and search text across title, description, and steps.

  public static async searchTasks(filter: TaskFilter): Promise<Task[]> {
    const tasks = await this.readTasks();
  
    return tasks.filter(task => {
      // 根據任務狀態過濾
      if (filter.status && task.status !== filter.status) {
        return false;
      }
  
      // 根據標籤過濾
      if (filter.tags && filter.tags.length > 0) {
        const hasAllTags = filter.tags.every(tag => task.tags.includes(tag));
        if (!hasAllTags) {
          return false;
        }
      }
  
      // 根據優先級過濾
      if (filter.priority && task.priority !== filter.priority) {
        return false;
      }
  
      // 根據期限過濾
      if (filter.dueDateFrom && task.dueDate) {
        const dueDateFrom = new Date(filter.dueDateFrom);
        const taskDueDate = new Date(task.dueDate);
        if (taskDueDate < dueDateFrom) {
          return false;
        }
      }
  
      if (filter.dueDateTo && task.dueDate) {
        const dueDateTo = new Date(filter.dueDateTo);
        const taskDueDate = new Date(task.dueDate);
  
        // 根據預計開始時間過濾
        if (filter.plannedStartDateFrom && task.plannedStartDate) {
          const plannedStartDateFrom = new Date(filter.plannedStartDateFrom);
          const taskPlannedStartDate = new Date(task.plannedStartDate);
          if (taskPlannedStartDate < plannedStartDateFrom) {
            return false;
          }
        }
  
        if (filter.plannedStartDateTo && task.plannedStartDate) {
          const plannedStartDateTo = new Date(filter.plannedStartDateTo);
          const taskPlannedStartDate = new Date(task.plannedStartDate);
          if (taskPlannedStartDate > plannedStartDateTo) {
            return false;
          }
        }
        if (taskDueDate > dueDateTo) {
          return false;
        }
      }
  
      // 根據建立時間過濾
      if (filter.createdFrom) {
        const createdFrom = new Date(filter.createdFrom);
        const taskCreatedDate = new Date(task.createdAt);
        if (taskCreatedDate < createdFrom) {
          return false;
        }
      }
  
      if (filter.createdTo) {
        const createdTo = new Date(filter.createdTo);
        const taskCreatedDate = new Date(task.createdAt);
        if (taskCreatedDate > createdTo) {
          return false;
        }
      }
  
      // 根據文本搜索
      if (filter.searchText) {
        const searchText = filter.searchText.toLowerCase();
        const matchesTitle = task.title.toLowerCase().includes(searchText);
        const matchesDescription = task.description.toLowerCase().includes(searchText);
        const matchesSteps = task.steps.some(step =>
          step.description.toLowerCase().includes(searchText)
        );
  
        if (!matchesTitle && !matchesDescription && !matchesSteps) {
          return false;
        }
      }
  
      return true;
    });
  }

• tools/interfaces/TaskManager.ts:114-125 (schema)

  TypeScript interface defining the TaskFilter type used for task search parameters, matching the tool's input schema.

  export interface TaskFilter {
    status?: TaskStatus;
      plannedStartDateFrom?: string;
      plannedStartDateTo?: string;
    tags?: string[];
    priority?: number;
    dueDateFrom?: string;
    dueDateTo?: string;
    createdFrom?: string;
    createdTo?: string;
    searchText?: string;
  }

• tools/interfaces/TaskManager.ts:104-108 (schema)

  TaskStatus enum used in the input schema for filtering by task status.

  export enum TaskStatus {
    PENDING = "pending",
    IN_PROGRESS = "in_progress",
    COMPLETED = "completed",
    CANCELLED = "cancelled"