roadmap-skill 0.2.3 → 0.2.5

package/dist/web/server.js

@@ -69,6 +69,7 @@ var init_file_helpers = __esm({
 init_esm_shims();
 import express from "express";
 import * as path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/storage/index.ts
 init_esm_shims();
@@ -268,10 +269,662 @@ var ProjectStorage = class {
     }
     return results;
   }
+  async exportAllData() {
+    await this.ensureDirectory();
+    const fs2 = await import("fs/promises");
+    const files = await fs2.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();
 
+// 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 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 this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          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 tag = {
+        id: generateTagId(),
+        name: data.name,
+        color: data.color,
+        description: data.description || "",
+        createdAt: now
+      };
+      projectData.tags.push(tag);
+      projectData.project.updatedAt = now;
+      await this.saveProjectData(projectId, projectData);
+      return {
+        success: true,
+        data: tag
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create tag",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  /**
+   * List all tags in a project
+   * @param projectId - The project ID
+   * @returns Array of tags or error
+   */
+  async list(projectId) {
+    try {
+      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: projectData.tags
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list tags",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  /**
+   * 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 this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      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: "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: updatedTag
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update tag",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  /**
+   * 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 this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      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"
+        };
+      }
+      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(tagId);
+        if (tagIndexInTask !== -1) {
+          task.tags.splice(tagIndexInTask, 1);
+          task.updatedAt = now;
+          tasksUpdated++;
+        }
+      }
+      projectData.tags.splice(tagIndex, 1);
+      projectData.project.updatedAt = now;
+      await this.saveProjectData(projectId, projectData);
+      return {
+        success: true,
+        data: {
+          deleted: true,
+          tag,
+          tasksUpdated
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete tag",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+  /**
+   * 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 this.storage.readProject(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`,
+          code: "NOT_FOUND"
+        };
+      }
+      const tag = projectData.tags.find(
+        (t) => t.name.toLowerCase() === tagName.toLowerCase()
+      );
+      if (!tag) {
+        return {
+          success: false,
+          error: `Tag with name '${tagName}' not found in project '${projectId}'`,
+          code: "NOT_FOUND"
+        };
+      }
+      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",
+        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);
+  }
+};
+
+// 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(projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          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 taskIds) {
+        const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+        if (taskIndex === -1) {
+          notFoundIds.push(taskId);
+          continue;
+        }
+        const existingTask = projectData.tasks[taskIndex];
+        let updatedTags = existingTask.tags;
+        if (data.tags && data.tags.length > 0) {
+          const existingTags = existingTask.tags || [];
+          switch (data.tagOperation) {
+            case "add":
+              updatedTags = [.../* @__PURE__ */ new Set([...existingTags, ...data.tags])];
+              break;
+            case "remove":
+              updatedTags = existingTags.filter((tag) => !data.tags.includes(tag));
+              break;
+            case "replace":
+            default:
+              updatedTags = data.tags;
+              break;
+          }
+        }
+        const completedAt = calculateCompletedAt(
+          existingTask.status,
+          data.status,
+          existingTask.completedAt,
+          now
+        );
+        const updatedTask = {
+          ...existingTask,
+          ...data.status && { status: data.status },
+          ...data.priority && { priority: data.priority },
+          tags: updatedTags,
+          updatedAt: now,
+          completedAt
+        };
+        projectData.tasks[taskIndex] = updatedTask;
+        updatedTasks.push(updatedTask);
+      }
+      if (updatedTasks.length === 0) {
+        return {
+          success: false,
+          error: "No tasks were found to update",
+          code: "NOT_FOUND"
+        };
+      }
+      projectData.project.updatedAt = now;
+      const filePath = storage.getFilePath(projectId);
+      await writeJsonFile(filePath, projectData);
+      return {
+        success: true,
+        data: {
+          updatedTasks,
+          updatedCount: updatedTasks.length,
+          notFoundIds: notFoundIds.length > 0 ? notFoundIds : void 0
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to batch update tasks",
+        code: "INTERNAL_ERROR"
+      };
+    }
+  }
+};
+
+// src/services/types.ts
+init_esm_shims();
+
 // src/web/server.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path4.dirname(__filename2);
+var tagService = new TagService(storage);
 function createServer(port = 7860) {
   return new Promise((resolve, reject) => {
     const app = express();
@@ -337,31 +990,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 });
       }
@@ -369,33 +1004,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 });
       }
@@ -403,27 +1018,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 tagService.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 tagService.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 tagService.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 tagService.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")) {
@@ -446,6 +1130,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);
+  });
+}
 export {
   createServer
 };