roadmap-skill 0.2.3 → 0.2.5

package/dist/index.js

@@ -287,6 +287,58 @@ var ProjectStorage = class {
     }
     return results;
   }
+  async exportAllData() {
+    await this.ensureDirectory();
+    const fs3 = await import("fs/promises");
+    const files = await fs3.readdir(this.storageDir);
+    const jsonFiles = files.filter((f) => f.endsWith(".json"));
+    const projects = [];
+    for (const file of jsonFiles) {
+      try {
+        const filePath = path3.join(this.storageDir, file);
+        const data = await readJsonFile(filePath);
+        projects.push(data);
+      } catch {
+        continue;
+      }
+    }
+    return {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projects
+    };
+  }
+  async importAllData(data) {
+    await this.ensureDirectory();
+    let imported = 0;
+    let errors = 0;
+    const errorDetails = [];
+    if (!data.projects || !Array.isArray(data.projects)) {
+      throw new Error("Invalid backup data: projects array is required");
+    }
+    for (const projectData of data.projects) {
+      try {
+        if (!projectData.project || !projectData.project.id) {
+          errors++;
+          errorDetails.push("Skipping invalid project: missing project or id");
+          continue;
+        }
+        const filePath = this.getFilePath(projectData.project.id);
+        await writeJsonFile(filePath, projectData);
+        imported++;
+      } catch (error) {
+        errors++;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errorDetails.push(`Failed to import project ${projectData.project?.id || "unknown"}: ${errorMessage}`);
+      }
+    }
+    return {
+      success: errors === 0,
+      imported,
+      errors,
+      errorDetails
+    };
+  }
 };
 var storage = new ProjectStorage();
 
@@ -443,266 +495,534 @@ var deleteProjectTool = {
 // src/tools/task-tools.ts
 init_esm_shims();
 import { z as z2 } from "zod";
-var TaskStatusEnum = z2.enum(["todo", "in-progress", "review", "done"]);
-var TaskPriorityEnum = z2.enum(["low", "medium", "high", "critical"]);
-function generateTaskId() {
-  return `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+
+// src/services/index.ts
+init_esm_shims();
+
+// src/services/tag-service.ts
+init_esm_shims();
+function generateTagId() {
+  return `tag_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
-var createTaskTool = {
-  name: "create_task",
-  description: "Create a new task in a project",
-  inputSchema: z2.object({
-    projectId: z2.string().min(1, "Project ID is required"),
-    title: z2.string().min(1, "Task title is required"),
-    description: z2.string(),
-    priority: TaskPriorityEnum.default("medium"),
-    tags: z2.array(z2.string()).default([]),
-    dueDate: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
-    assignee: z2.string().optional()
-  }),
-  async execute(input) {
+var TagService = class {
+  storage;
+  constructor(storage2) {
+    this.storage = storage2;
+  }
+  /**
+   * Create a new tag in a project
+   * @param projectId - The project ID
+   * @param data - Tag creation data
+   * @returns The created tag or error
+   */
+  async create(projectId, data) {
     try {
-      const projectData = await storage.readProject(input.projectId);
+      const projectData = await this.storage.readProject(projectId);
       if (!projectData) {
         return {
           success: false,
-          error: `Project with ID '${input.projectId}' not found`
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const existingTag = projectData.tags.find(
+        (t) => t.name.toLowerCase() === data.name.toLowerCase()
+      );
+      if (existingTag) {
+        return {
+          success: false,
+          error: `Tag with name '${data.name}' already exists in this project`,
+          code: "DUPLICATE_ERROR"
         };
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const task = {
-        id: generateTaskId(),
-        projectId: input.projectId,
-        title: input.title,
-        description: input.description,
-        status: "todo",
-        priority: input.priority,
-        tags: input.tags,
-        dueDate: input.dueDate ?? null,
-        assignee: input.assignee ?? null,
-        createdAt: now,
-        updatedAt: now,
-        completedAt: null
+      const tag = {
+        id: generateTagId(),
+        name: data.name,
+        color: data.color,
+        description: data.description || "",
+        createdAt: now
       };
-      projectData.tasks.push(task);
+      projectData.tags.push(tag);
       projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
+      await this.saveProjectData(projectId, projectData);
       return {
         success: true,
-        data: task
+        data: tag
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to create task"
+        error: error instanceof Error ? error.message : "Failed to create tag",
+        code: "INTERNAL_ERROR"
       };
     }
   }
-};
-var listTasksTool = {
-  name: "list_tasks",
-  description: "List tasks with optional filters",
-  inputSchema: z2.object({
-    projectId: z2.string().optional(),
-    status: TaskStatusEnum.optional(),
-    priority: TaskPriorityEnum.optional(),
-    tags: z2.array(z2.string()).optional(),
-    assignee: z2.string().optional(),
-    dueBefore: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
-    dueAfter: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
-    includeCompleted: z2.boolean().optional()
-  }),
-  async execute(input) {
+  /**
+   * List all tags in a project
+   * @param projectId - The project ID
+   * @returns Array of tags or error
+   */
+  async list(projectId) {
     try {
-      const results = await storage.searchTasks({
-        projectId: input.projectId,
-        status: input.status,
-        priority: input.priority,
-        tags: input.tags,
-        assignee: input.assignee,
-        dueBefore: input.dueBefore,
-        dueAfter: input.dueAfter,
-        includeCompleted: input.includeCompleted
-      });
+      const projectData = await this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
       return {
         success: true,
-        data: results
+        data: projectData.tags
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to list tasks"
+        error: error instanceof Error ? error.message : "Failed to list tags",
+        code: "INTERNAL_ERROR"
       };
     }
   }
-};
-var getTaskTool = {
-  name: "get_task",
-  description: "Get a specific task by project ID and task ID",
-  inputSchema: z2.object({
-    projectId: z2.string().min(1, "Project ID is required"),
-    taskId: z2.string().min(1, "Task ID is required")
-  }),
-  async execute(input) {
+  /**
+   * Update an existing tag
+   * @param projectId - The project ID
+   * @param tagId - The tag ID
+   * @param data - Tag update data
+   * @returns The updated tag or error
+   */
+  async update(projectId, tagId, data) {
     try {
-      const projectData = await storage.readProject(input.projectId);
+      const projectData = await this.storage.readProject(projectId);
       if (!projectData) {
         return {
           success: false,
-          error: `Project with ID '${input.projectId}' not found`
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
-      const task = projectData.tasks.find((t) => t.id === input.taskId);
-      if (!task) {
+      const tagIndex = projectData.tags.findIndex((t) => t.id === tagId);
+      if (tagIndex === -1) {
+        return {
+          success: false,
+          error: `Tag with ID '${tagId}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
+        };
+      }
+      if (Object.keys(data).length === 0) {
         return {
           success: false,
-          error: `Task with ID '${input.taskId}' not found in project '${input.projectId}'`
+          error: "At least one field to update is required",
+          code: "VALIDATION_ERROR"
         };
       }
+      if (data.name) {
+        const existingTag2 = projectData.tags.find(
+          (t) => t.name.toLowerCase() === data.name.toLowerCase() && t.id !== tagId
+        );
+        if (existingTag2) {
+          return {
+            success: false,
+            error: `Tag with name '${data.name}' already exists in this project`,
+            code: "DUPLICATE_ERROR"
+          };
+        }
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existingTag = projectData.tags[tagIndex];
+      const updatedTag = {
+        ...existingTag,
+        ...data,
+        id: existingTag.id,
+        createdAt: existingTag.createdAt
+      };
+      projectData.tags[tagIndex] = updatedTag;
+      projectData.project.updatedAt = now;
+      await this.saveProjectData(projectId, projectData);
       return {
         success: true,
-        data: task
+        data: updatedTag
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to get task"
+        error: error instanceof Error ? error.message : "Failed to update tag",
+        code: "INTERNAL_ERROR"
       };
     }
   }
-};
-var updateTaskTool = {
-  name: "update_task",
-  description: "Update an existing task",
-  inputSchema: z2.object({
-    projectId: z2.string().min(1, "Project ID is required"),
-    taskId: z2.string().min(1, "Task ID is required"),
-    title: z2.string().min(1).optional(),
-    description: z2.string().optional(),
-    status: TaskStatusEnum.optional(),
-    priority: TaskPriorityEnum.optional(),
-    tags: z2.array(z2.string()).optional(),
-    dueDate: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().nullable(),
-    assignee: z2.string().optional().nullable()
-  }),
-  async execute(input) {
+  /**
+   * Delete a tag by ID
+   * Also removes the tag from all tasks that use it
+   * @param projectId - The project ID
+   * @param tagId - The tag ID
+   * @returns Delete result with tag info and count of updated tasks
+   */
+  async delete(projectId, tagId) {
     try {
-      const projectData = await storage.readProject(input.projectId);
+      const projectData = await this.storage.readProject(projectId);
       if (!projectData) {
         return {
           success: false,
-          error: `Project with ID '${input.projectId}' not found`
-        };
-      }
-      const taskIndex = projectData.tasks.findIndex((t) => t.id === input.taskId);
-      if (taskIndex === -1) {
-        return {
-          success: false,
-          error: `Task with ID '${input.taskId}' not found in project '${input.projectId}'`
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
-      const { projectId, taskId, ...updateData } = input;
-      if (Object.keys(updateData).length === 0) {
+      const tagIndex = projectData.tags.findIndex((t) => t.id === tagId);
+      if (tagIndex === -1) {
         return {
           success: false,
-          error: "At least one field to update is required"
+          error: `Tag with ID '${tagId}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
         };
       }
+      const tag = projectData.tags[tagIndex];
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const existingTask = projectData.tasks[taskIndex];
-      const updatedTask = {
-        ...existingTask,
-        ...updateData,
-        id: existingTask.id,
-        projectId: existingTask.projectId,
-        createdAt: existingTask.createdAt,
-        updatedAt: now,
-        completedAt: updateData.status === "done" && existingTask.status !== "done" ? now : updateData.status && updateData.status !== "done" ? null : existingTask.completedAt
-      };
-      projectData.tasks[taskIndex] = updatedTask;
+      let tasksUpdated = 0;
+      for (const task of projectData.tasks) {
+        const tagIndexInTask = task.tags.indexOf(tagId);
+        if (tagIndexInTask !== -1) {
+          task.tags.splice(tagIndexInTask, 1);
+          task.updatedAt = now;
+          tasksUpdated++;
+        }
+      }
+      projectData.tags.splice(tagIndex, 1);
       projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
+      await this.saveProjectData(projectId, projectData);
       return {
         success: true,
-        data: updatedTask
+        data: {
+          deleted: true,
+          tag,
+          tasksUpdated
+        }
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to update task"
+        error: error instanceof Error ? error.message : "Failed to delete tag",
+        code: "INTERNAL_ERROR"
       };
     }
   }
-};
-var deleteTaskTool = {
-  name: "delete_task",
-  description: "Delete a task by project ID and task ID",
-  inputSchema: z2.object({
-    projectId: z2.string().min(1, "Project ID is required"),
-    taskId: z2.string().min(1, "Task ID is required")
-  }),
-  async execute(input) {
+  /**
+   * Get all tasks that have a specific tag by tag name
+   * @param projectId - The project ID
+   * @param tagName - The tag name
+   * @returns Tag info and matching tasks
+   */
+  async getTasksByTag(projectId, tagName) {
     try {
-      const projectData = await storage.readProject(input.projectId);
+      const projectData = await this.storage.readProject(projectId);
       if (!projectData) {
         return {
           success: false,
-          error: `Project with ID '${input.projectId}' not found`
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
-      const taskIndex = projectData.tasks.findIndex((t) => t.id === input.taskId);
-      if (taskIndex === -1) {
+      const tag = projectData.tags.find(
+        (t) => t.name.toLowerCase() === tagName.toLowerCase()
+      );
+      if (!tag) {
         return {
           success: false,
-          error: `Task with ID '${input.taskId}' not found in project '${input.projectId}'`
+          error: `Tag with name '${tagName}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
         };
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      projectData.tasks.splice(taskIndex, 1);
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
+      const tasks = projectData.tasks.filter((t) => t.tags.includes(tag.id));
       return {
         success: true,
-        data: { deleted: true }
+        data: {
+          tag,
+          tasks,
+          count: tasks.length
+        }
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to delete task"
+        error: error instanceof Error ? error.message : "Failed to get tasks by tag",
+        code: "INTERNAL_ERROR"
       };
     }
   }
+  /**
+   * Helper method to save project data
+   * @param projectId - The project ID
+   * @param projectData - The project data to save
+   */
+  async saveProjectData(projectId, projectData) {
+    const filePath = this.storage.getFilePath(projectId);
+    const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
+    await writeJsonFile2(filePath, projectData);
+  }
 };
-var batchUpdateTasksTool = {
-  name: "batch_update_tasks",
-  description: "Update multiple tasks at once",
-  inputSchema: z2.object({
-    projectId: z2.string().min(1, "Project ID is required"),
-    taskIds: z2.array(z2.string()).min(1, "At least one task ID is required"),
-    status: TaskStatusEnum.optional(),
-    priority: TaskPriorityEnum.optional(),
-    tags: z2.array(z2.string()).optional(),
-    tagOperation: z2.enum(["add", "remove", "replace"]).default("replace")
-  }),
-  async execute(input) {
+
+// src/services/task-service.ts
+init_esm_shims();
+init_file_helpers();
+function generateTaskId() {
+  return `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function calculateCompletedAt(currentStatus, newStatus, existingCompletedAt, now) {
+  if (!newStatus) {
+    return existingCompletedAt;
+  }
+  if (newStatus === "done" && currentStatus !== "done") {
+    return now;
+  }
+  if (currentStatus === "done" && newStatus !== "done") {
+    return null;
+  }
+  return existingCompletedAt;
+}
+var TaskService = {
+  /**
+   * Create a new task in a project
+   * @param projectId - The project ID
+   * @param data - Task creation data
+   * @returns The created task or error
+   */
+  async create(projectId, data) {
     try {
-      const projectData = await storage.readProject(input.projectId);
+      const projectData = await storage.readProject(projectId);
       if (!projectData) {
         return {
           success: false,
-          error: `Project with ID '${input.projectId}' not found`
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const task = {
+        id: generateTaskId(),
+        projectId,
+        title: data.title,
+        description: data.description,
+        status: "todo",
+        priority: data.priority ?? "medium",
+        tags: data.tags ?? [],
+        dueDate: data.dueDate ?? null,
+        assignee: data.assignee ?? null,
+        createdAt: now,
+        updatedAt: now,
+        completedAt: null
+      };
+      projectData.tasks.push(task);
+      projectData.project.updatedAt = now;
+      const filePath = storage.getFilePath(projectId);
+      await writeJsonFile(filePath, projectData);
+      return {
+        success: true,
+        data: task
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create task",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  },
+  /**
+   * Get a specific task by project ID and task ID
+   * @param projectId - The project ID
+   * @param taskId - The task ID
+   * @returns The task or error
+   */
+  async get(projectId, taskId) {
+    try {
+      const projectData = await storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const task = projectData.tasks.find((t) => t.id === taskId);
+      if (!task) {
+        return {
+          success: false,
+          error: `Task with ID '${taskId}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
+        };
+      }
+      return {
+        success: true,
+        data: task
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get task",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  },
+  /**
+   * Update an existing task
+   * Handles completedAt automatically based on status changes
+   * @param projectId - The project ID
+   * @param taskId - The task ID
+   * @param data - Task update data
+   * @returns The updated task or error
+   */
+  async update(projectId, taskId, data) {
+    try {
+      const projectData = await storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+      if (taskIndex === -1) {
+        return {
+          success: false,
+          error: `Task with ID '${taskId}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
+        };
+      }
+      const updateKeys = Object.keys(data);
+      if (updateKeys.length === 0) {
+        return {
+          success: false,
+          error: "At least one field to update is required",
+          code: "VALIDATION_ERROR"
+        };
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existingTask = projectData.tasks[taskIndex];
+      const completedAt = calculateCompletedAt(
+        existingTask.status,
+        data.status,
+        existingTask.completedAt,
+        now
+      );
+      const updatedTask = {
+        ...existingTask,
+        ...data,
+        id: existingTask.id,
+        projectId: existingTask.projectId,
+        createdAt: existingTask.createdAt,
+        updatedAt: now,
+        completedAt
+      };
+      projectData.tasks[taskIndex] = updatedTask;
+      projectData.project.updatedAt = now;
+      const filePath = storage.getFilePath(projectId);
+      await writeJsonFile(filePath, projectData);
+      return {
+        success: true,
+        data: updatedTask
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update task",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  },
+  /**
+   * Delete a task by project ID and task ID
+   * @param projectId - The project ID
+   * @param taskId - The task ID
+   * @returns Void or error
+   */
+  async delete(projectId, taskId) {
+    try {
+      const projectData = await storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+      if (taskIndex === -1) {
+        return {
+          success: false,
+          error: `Task with ID '${taskId}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
+        };
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      projectData.tasks.splice(taskIndex, 1);
+      projectData.project.updatedAt = now;
+      const filePath = storage.getFilePath(projectId);
+      await writeJsonFile(filePath, projectData);
+      return {
+        success: true,
+        data: void 0
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete task",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  },
+  /**
+   * List tasks with optional filters
+   * @param filters - Optional filters for the search
+   * @returns Array of tasks or error
+   */
+  async list(filters) {
+    try {
+      const results = await storage.searchTasks({
+        projectId: filters?.projectId,
+        status: filters?.status,
+        priority: filters?.priority,
+        tags: filters?.tags,
+        assignee: filters?.assignee,
+        dueBefore: filters?.dueBefore,
+        dueAfter: filters?.dueAfter,
+        includeCompleted: filters?.includeCompleted
+      });
+      const tasks = results.map((r) => r.task);
+      return {
+        success: true,
+        data: tasks
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list tasks",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  },
+  /**
+   * Update multiple tasks at once
+   * @param projectId - The project ID
+   * @param taskIds - Array of task IDs to update
+   * @param data - Batch update data
+   * @returns Batch update result or error
+   */
+  async batchUpdate(projectId, taskIds, data) {
+    try {
+      const projectData = await storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
         };
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const updatedTasks = [];
       const notFoundIds = [];
-      for (const taskId of input.taskIds) {
+      for (const taskId of taskIds) {
         const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
         if (taskIndex === -1) {
           notFoundIds.push(taskId);
@@ -710,29 +1030,34 @@ var batchUpdateTasksTool = {
         }
         const existingTask = projectData.tasks[taskIndex];
         let updatedTags = existingTask.tags;
-        if (input.tags && input.tags.length > 0) {
+        if (data.tags && data.tags.length > 0) {
           const existingTags = existingTask.tags || [];
-          switch (input.tagOperation) {
+          switch (data.tagOperation) {
             case "add":
-              updatedTags = [.../* @__PURE__ */ new Set([...existingTags, ...input.tags])];
+              updatedTags = [.../* @__PURE__ */ new Set([...existingTags, ...data.tags])];
               break;
             case "remove":
-              updatedTags = existingTags.filter((tag) => !input.tags.includes(tag));
+              updatedTags = existingTags.filter((tag) => !data.tags.includes(tag));
               break;
             case "replace":
             default:
-              updatedTags = input.tags;
+              updatedTags = data.tags;
               break;
           }
         }
+        const completedAt = calculateCompletedAt(
+          existingTask.status,
+          data.status,
+          existingTask.completedAt,
+          now
+        );
         const updatedTask = {
           ...existingTask,
-          ...input.status && { status: input.status },
-          ...input.priority && { priority: input.priority },
+          ...data.status && { status: data.status },
+          ...data.priority && { priority: data.priority },
           tags: updatedTags,
           updatedAt: now,
-          ...input.status === "done" && existingTask.status !== "done" && { completedAt: now },
-          ...input.status && input.status !== "done" && { completedAt: null }
+          completedAt
         };
         projectData.tasks[taskIndex] = updatedTask;
         updatedTasks.push(updatedTask);
@@ -741,13 +1066,12 @@ var batchUpdateTasksTool = {
         return {
           success: false,
           error: "No tasks were found to update",
-          notFoundIds
+          code: "NOT_FOUND"
         };
       }
       projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
+      const filePath = storage.getFilePath(projectId);
+      await writeJsonFile(filePath, projectData);
       return {
         success: true,
         data: {
@@ -759,18 +1083,155 @@ var batchUpdateTasksTool = {
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : "Failed to batch update tasks"
+        error: error instanceof Error ? error.message : "Failed to batch update tasks",
+        code: "INTERNAL_ERROR"
       };
     }
   }
 };
 
+// src/services/types.ts
+init_esm_shims();
+
+// src/tools/task-tools.ts
+var TaskStatusEnum = z2.enum(["todo", "in-progress", "review", "done"]);
+var TaskPriorityEnum = z2.enum(["low", "medium", "high", "critical"]);
+var createTaskTool = {
+  name: "create_task",
+  description: "Create a new task in a project",
+  inputSchema: z2.object({
+    projectId: z2.string().min(1, "Project ID is required"),
+    title: z2.string().min(1, "Task title is required"),
+    description: z2.string(),
+    priority: TaskPriorityEnum.default("medium"),
+    tags: z2.array(z2.string()).default([]),
+    dueDate: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    assignee: z2.string().optional()
+  }),
+  async execute(input) {
+    const result = await TaskService.create(input.projectId, {
+      title: input.title,
+      description: input.description,
+      priority: input.priority,
+      tags: input.tags,
+      dueDate: input.dueDate,
+      assignee: input.assignee
+    });
+    return result;
+  }
+};
+var listTasksTool = {
+  name: "list_tasks",
+  description: "List tasks with optional filters",
+  inputSchema: z2.object({
+    projectId: z2.string().optional(),
+    status: TaskStatusEnum.optional(),
+    priority: TaskPriorityEnum.optional(),
+    tags: z2.array(z2.string()).optional(),
+    assignee: z2.string().optional(),
+    dueBefore: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    dueAfter: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    includeCompleted: z2.boolean().optional()
+  }),
+  async execute(input) {
+    try {
+      const results = await storage.searchTasks({
+        projectId: input.projectId,
+        status: input.status,
+        priority: input.priority,
+        tags: input.tags,
+        assignee: input.assignee,
+        dueBefore: input.dueBefore,
+        dueAfter: input.dueAfter,
+        includeCompleted: input.includeCompleted
+      });
+      return {
+        success: true,
+        data: results
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list tasks"
+      };
+    }
+  }
+};
+var getTaskTool = {
+  name: "get_task",
+  description: "Get a specific task by project ID and task ID",
+  inputSchema: z2.object({
+    projectId: z2.string().min(1, "Project ID is required"),
+    taskId: z2.string().min(1, "Task ID is required")
+  }),
+  async execute(input) {
+    const result = await TaskService.get(input.projectId, input.taskId);
+    return result;
+  }
+};
+var updateTaskTool = {
+  name: "update_task",
+  description: "Update an existing task",
+  inputSchema: z2.object({
+    projectId: z2.string().min(1, "Project ID is required"),
+    taskId: z2.string().min(1, "Task ID is required"),
+    title: z2.string().min(1).optional(),
+    description: z2.string().optional(),
+    status: TaskStatusEnum.optional(),
+    priority: TaskPriorityEnum.optional(),
+    tags: z2.array(z2.string()).optional(),
+    dueDate: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().nullable(),
+    assignee: z2.string().optional().nullable()
+  }),
+  async execute(input) {
+    const { projectId, taskId, ...updateData } = input;
+    const result = await TaskService.update(projectId, taskId, updateData);
+    return result;
+  }
+};
+var deleteTaskTool = {
+  name: "delete_task",
+  description: "Delete a task by project ID and task ID",
+  inputSchema: z2.object({
+    projectId: z2.string().min(1, "Project ID is required"),
+    taskId: z2.string().min(1, "Task ID is required")
+  }),
+  async execute(input) {
+    const result = await TaskService.delete(input.projectId, input.taskId);
+    if (result.success) {
+      return {
+        success: true,
+        data: { deleted: true }
+      };
+    }
+    return result;
+  }
+};
+var batchUpdateTasksTool = {
+  name: "batch_update_tasks",
+  description: "Update multiple tasks at once",
+  inputSchema: z2.object({
+    projectId: z2.string().min(1, "Project ID is required"),
+    taskIds: z2.array(z2.string()).min(1, "At least one task ID is required"),
+    status: TaskStatusEnum.optional(),
+    priority: TaskPriorityEnum.optional(),
+    tags: z2.array(z2.string()).optional(),
+    tagOperation: z2.enum(["add", "remove", "replace"]).default("replace")
+  }),
+  async execute(input) {
+    const { projectId, taskIds, tagOperation, ...restData } = input;
+    const result = await TaskService.batchUpdate(projectId, taskIds, {
+      ...restData,
+      tagOperation
+    });
+    return result;
+  }
+};
+
 // src/tools/tag-tools.ts
 init_esm_shims();
 import { z as z3 } from "zod";
-function generateTagId() {
-  return `tag_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
+var tagService = new TagService(storage);
 var createTagTool = {
   name: "create_tag",
   description: "Create a new tag in a project",
@@ -781,46 +1242,12 @@ var createTagTool = {
     description: z3.string().default("")
   }),
   async execute(input) {
-    try {
-      const projectData = await storage.readProject(input.projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${input.projectId}' not found`
-        };
-      }
-      const existingTag = projectData.tags.find(
-        (t) => t.name.toLowerCase() === input.name.toLowerCase()
-      );
-      if (existingTag) {
-        return {
-          success: false,
-          error: `Tag with name '${input.name}' already exists in this project`
-        };
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const tag = {
-        id: generateTagId(),
-        name: input.name,
-        color: input.color,
-        description: input.description,
-        createdAt: now
-      };
-      projectData.tags.push(tag);
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
-      return {
-        success: true,
-        data: tag
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to create tag"
-      };
+    const { projectId, ...data } = input;
+    const result = await tagService.create(projectId, data);
+    if (!result.success) {
+      return { success: false, error: result.error };
     }
+    return { success: true, data: result.data };
   }
 };
 var listTagsTool = {
@@ -830,24 +1257,11 @@ var listTagsTool = {
     projectId: z3.string().min(1, "Project ID is required")
   }),
   async execute(input) {
-    try {
-      const projectData = await storage.readProject(input.projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${input.projectId}' not found`
-        };
-      }
-      return {
-        success: true,
-        data: projectData.tags
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to list tags"
-      };
+    const result = await tagService.list(input.projectId);
+    if (!result.success) {
+      return { success: false, error: result.error };
     }
+    return { success: true, data: result.data };
   }
 };
 var updateTagTool = {
@@ -861,62 +1275,12 @@ var updateTagTool = {
     description: z3.string().optional()
   }),
   async execute(input) {
-    try {
-      const projectData = await storage.readProject(input.projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${input.projectId}' not found`
-        };
-      }
-      const tagIndex = projectData.tags.findIndex((t) => t.id === input.tagId);
-      if (tagIndex === -1) {
-        return {
-          success: false,
-          error: `Tag with ID '${input.tagId}' not found in project '${input.projectId}'`
-        };
-      }
-      const { projectId, tagId, ...updateData } = input;
-      if (Object.keys(updateData).length === 0) {
-        return {
-          success: false,
-          error: "At least one field to update is required"
-        };
-      }
-      if (updateData.name) {
-        const existingTag2 = projectData.tags.find(
-          (t) => t.name.toLowerCase() === updateData.name.toLowerCase() && t.id !== input.tagId
-        );
-        if (existingTag2) {
-          return {
-            success: false,
-            error: `Tag with name '${updateData.name}' already exists in this project`
-          };
-        }
-      }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const existingTag = projectData.tags[tagIndex];
-      const updatedTag = {
-        ...existingTag,
-        ...updateData,
-        id: existingTag.id,
-        createdAt: existingTag.createdAt
-      };
-      projectData.tags[tagIndex] = updatedTag;
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
-      return {
-        success: true,
-        data: updatedTag
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to update tag"
-      };
+    const { projectId, tagId, ...data } = input;
+    const result = await tagService.update(projectId, tagId, data);
+    if (!result.success) {
+      return { success: false, error: result.error };
     }
+    return { success: true, data: result.data };
   }
 };
 var deleteTagTool = {
@@ -927,51 +1291,11 @@ var deleteTagTool = {
     tagId: z3.string().min(1, "Tag ID is required")
   }),
   async execute(input) {
-    try {
-      const projectData = await storage.readProject(input.projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${input.projectId}' not found`
-        };
-      }
-      const tagIndex = projectData.tags.findIndex((t) => t.id === input.tagId);
-      if (tagIndex === -1) {
-        return {
-          success: false,
-          error: `Tag with ID '${input.tagId}' not found in project '${input.projectId}'`
-        };
-      }
-      const tag = projectData.tags[tagIndex];
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      let tasksUpdated = 0;
-      for (const task of projectData.tasks) {
-        const tagIndexInTask = task.tags.indexOf(input.tagId);
-        if (tagIndexInTask !== -1) {
-          task.tags.splice(tagIndexInTask, 1);
-          task.updatedAt = now;
-          tasksUpdated++;
-        }
-      }
-      projectData.tags.splice(tagIndex, 1);
-      projectData.project.updatedAt = now;
-      const filePath = storage.getFilePath(input.projectId);
-      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-      await writeJsonFile2(filePath, projectData);
-      return {
-        success: true,
-        data: {
-          deleted: true,
-          tag,
-          tasksUpdated
-        }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to delete tag"
-      };
+    const result = await tagService.delete(input.projectId, input.tagId);
+    if (!result.success) {
+      return { success: false, error: result.error };
     }
+    return { success: true, data: result.data };
   }
 };
 var getTasksByTagTool = {
@@ -982,38 +1306,11 @@ var getTasksByTagTool = {
     tagName: z3.string().min(1, "Tag name is required")
   }),
   async execute(input) {
-    try {
-      const projectData = await storage.readProject(input.projectId);
-      if (!projectData) {
-        return {
-          success: false,
-          error: `Project with ID '${input.projectId}' not found`
-        };
-      }
-      const tag = projectData.tags.find(
-        (t) => t.name.toLowerCase() === input.tagName.toLowerCase()
-      );
-      if (!tag) {
-        return {
-          success: false,
-          error: `Tag with name '${input.tagName}' not found in project '${input.projectId}'`
-        };
-      }
-      const tasks = projectData.tasks.filter((t) => t.tags.includes(tag.id));
-      return {
-        success: true,
-        data: {
-          tag,
-          tasks,
-          count: tasks.length
-        }
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to get tasks by tag"
-      };
+    const result = await tagService.getTasksByTag(input.projectId, input.tagName);
+    if (!result.success) {
+      return { success: false, error: result.error };
     }
+    return { success: true, data: result.data };
   }
 };
 
@@ -1024,6 +1321,10 @@ init_esm_shims();
 init_esm_shims();
 import express from "express";
 import * as path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+var tagService2 = new TagService(storage);
 function createServer(port = 7860) {
   return new Promise((resolve, reject) => {
     const app = express();
@@ -1089,31 +1390,13 @@ function createServer(port = 7860) {
     app.post("/api/tasks", async (req, res) => {
       try {
         const { projectId, ...taskData } = req.body;
-        const projectData = await storage.readProject(projectId);
-        if (!projectData) {
-          res.status(404).json({ error: "Project not found" });
+        const result = await TaskService.create(projectId, taskData);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
           return;
         }
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const task = {
-          id: `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
-          projectId,
-          ...taskData,
-          status: taskData.status || "todo",
-          priority: taskData.priority || "medium",
-          tags: taskData.tags || [],
-          dueDate: taskData.dueDate || null,
-          assignee: taskData.assignee || null,
-          createdAt: now,
-          updatedAt: now,
-          completedAt: null
-        };
-        projectData.tasks.push(task);
-        projectData.project.updatedAt = now;
-        const filePath = storage.getFilePath(projectId);
-        const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-        await writeJsonFile2(filePath, projectData);
-        res.json({ success: true, data: task });
+        res.json({ success: true, data: result.data });
       } catch (error) {
         res.status(500).json({ error: error.message });
       }
@@ -1121,33 +1404,13 @@ function createServer(port = 7860) {
     app.put("/api/tasks", async (req, res) => {
       try {
         const { projectId, taskId, ...updateData } = req.body;
-        const projectData = await storage.readProject(projectId);
-        if (!projectData) {
-          res.status(404).json({ error: "Project not found" });
+        const result = await TaskService.update(projectId, taskId, updateData);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
           return;
         }
-        const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-        if (taskIndex === -1) {
-          res.status(404).json({ error: "Task not found" });
-          return;
-        }
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const existingTask = projectData.tasks[taskIndex];
-        const updatedTask = {
-          ...existingTask,
-          ...updateData,
-          id: existingTask.id,
-          projectId: existingTask.projectId,
-          createdAt: existingTask.createdAt,
-          updatedAt: now,
-          completedAt: updateData.status === "done" && existingTask.status !== "done" ? now : updateData.status && updateData.status !== "done" ? null : existingTask.completedAt
-        };
-        projectData.tasks[taskIndex] = updatedTask;
-        projectData.project.updatedAt = now;
-        const filePath = storage.getFilePath(projectId);
-        const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-        await writeJsonFile2(filePath, projectData);
-        res.json({ success: true, data: updatedTask });
+        res.json({ success: true, data: result.data });
       } catch (error) {
         res.status(500).json({ error: error.message });
       }
@@ -1155,27 +1418,96 @@ function createServer(port = 7860) {
     app.delete("/api/tasks", async (req, res) => {
       try {
         const { projectId, taskId } = req.query;
-        const projectData = await storage.readProject(projectId);
-        if (!projectData) {
-          res.status(404).json({ error: "Project not found" });
+        const result = await TaskService.delete(projectId, taskId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
           return;
         }
-        const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-        if (taskIndex === -1) {
-          res.status(404).json({ error: "Task not found" });
+        res.json({ success: true });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.post("/api/projects/:projectId/tags", async (req, res) => {
+      try {
+        const { projectId } = req.params;
+        const result = await tagService2.create(projectId, req.body);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
           return;
         }
-        projectData.tasks.splice(taskIndex, 1);
-        projectData.project.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        const filePath = storage.getFilePath(projectId);
-        const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
-        await writeJsonFile2(filePath, projectData);
-        res.json({ success: true });
+        res.json({ success: true, data: result.data });
       } catch (error) {
         res.status(500).json({ error: error.message });
       }
     });
-    const distPath = path4.join(process.cwd(), "dist", "web", "app");
+    app.get("/api/projects/:projectId/tags", async (req, res) => {
+      try {
+        const { projectId } = req.params;
+        const result = await tagService2.list(projectId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: result.data });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.put("/api/projects/:projectId/tags/:tagId", async (req, res) => {
+      try {
+        const { projectId, tagId } = req.params;
+        const result = await tagService2.update(projectId, tagId, req.body);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: result.data });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.delete("/api/projects/:projectId/tags/:tagId", async (req, res) => {
+      try {
+        const { projectId, tagId } = req.params;
+        const result = await tagService2.delete(projectId, tagId);
+        if (!result.success) {
+          const statusCode = result.code === "NOT_FOUND" ? 404 : 400;
+          res.status(statusCode).json({ error: result.error });
+          return;
+        }
+        res.json({ success: true, data: result.data });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.get("/api/backup", async (_req, res) => {
+      try {
+        const backup = await storage.exportAllData();
+        const filename = `roadmap-skill-backup-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`;
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+        res.json(backup);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+    app.post("/api/backup", async (req, res) => {
+      try {
+        const result = await storage.importAllData(req.body);
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({
+          success: false,
+          error: error.message
+        });
+      }
+    });
+    const distPath = path4.join(__dirname2, "app");
     app.use(express.static(distPath));
     app.get("*", (req, res) => {
       if (req.path.startsWith("/api")) {
@@ -1198,6 +1530,13 @@ function createServer(port = 7860) {
     });
   });
 }
+if (process.argv[1]?.endsWith("server.js")) {
+  const port = parseInt(process.argv[2] || "7860", 10);
+  createServer(port).catch((err) => {
+    console.error("Failed to start server:", err);
+    process.exit(1);
+  });
+}
 
 // src/tools/web-tools.ts
 import open from "open";