roadmap-skill 0.1.0

package/dist/index.js

@@ -0,0 +1,2203 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/file-helpers.ts
+var file_helpers_exports = {};
+__export(file_helpers_exports, {
+  ensureDir: () => ensureDir,
+  readJsonFile: () => readJsonFile,
+  writeJsonFile: () => writeJsonFile
+});
+import * as fs from "fs/promises";
+async function readJsonFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to read JSON file ${filePath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  try {
+    const content = JSON.stringify(data, null, 2);
+    await fs.writeFile(filePath, content, "utf-8");
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to write JSON file ${filePath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+async function ensureDir(dirPath) {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to create directory ${dirPath}: ${error.message}`);
+    }
+    throw error;
+  }
+}
+var init_file_helpers = __esm({
+  "src/utils/file-helpers.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/server.ts
+init_esm_shims();
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/index.ts
+init_esm_shims();
+
+// src/tools/project-tools.ts
+init_esm_shims();
+import { z } from "zod";
+
+// src/storage/index.ts
+init_esm_shims();
+import * as path3 from "path";
+
+// src/utils/path-helpers.ts
+init_esm_shims();
+import * as os from "os";
+import * as path2 from "path";
+function getStorageDir() {
+  const homeDir = os.homedir();
+  return path2.join(homeDir, ".roadmap-skill", "projects");
+}
+
+// src/storage/index.ts
+init_file_helpers();
+var ProjectStorage = class {
+  storageDir;
+  constructor() {
+    this.storageDir = getStorageDir();
+  }
+  /**
+   * Ensure the storage directory exists
+   */
+  async ensureDirectory() {
+    await ensureDir(this.storageDir);
+  }
+  /**
+   * Get the file path for a project
+   * @param projectId - The project ID
+   * @returns Full path to the project JSON file
+   */
+  getFilePath(projectId) {
+    return path3.join(this.storageDir, `${projectId}.json`);
+  }
+  /**
+   * Create a new project
+   * @param input - Project creation data
+   * @returns The created project data
+   */
+  async createProject(input) {
+    await this.ensureDirectory();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const projectId = `proj_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const project = {
+      id: projectId,
+      name: input.name,
+      description: input.description,
+      projectType: input.projectType,
+      status: "active",
+      startDate: input.startDate,
+      targetDate: input.targetDate,
+      createdAt: now,
+      updatedAt: now
+    };
+    const projectData = {
+      version: 1,
+      project,
+      milestones: [],
+      tasks: [],
+      tags: []
+    };
+    const filePath = this.getFilePath(projectId);
+    await writeJsonFile(filePath, projectData);
+    return projectData;
+  }
+  /**
+   * Read a project by ID
+   * @param projectId - The project ID
+   * @returns The project data or null if not found
+   */
+  async readProject(projectId) {
+    try {
+      const filePath = this.getFilePath(projectId);
+      return await readJsonFile(filePath);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ENOENT")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Update an existing project
+   * @param projectId - The project ID
+   * @param input - Project update data
+   * @returns The updated project data or null if not found
+   */
+  async updateProject(projectId, input) {
+    const projectData = await this.readProject(projectId);
+    if (!projectData) {
+      return null;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    projectData.project = {
+      ...projectData.project,
+      ...input,
+      updatedAt: now
+    };
+    const filePath = this.getFilePath(projectId);
+    await writeJsonFile(filePath, projectData);
+    return projectData;
+  }
+  /**
+   * Delete a project by ID
+   * @param projectId - The project ID
+   * @returns True if deleted, false if not found
+   */
+  async deleteProject(projectId) {
+    try {
+      const filePath = this.getFilePath(projectId);
+      const fs3 = await import("fs/promises");
+      await fs3.unlink(filePath);
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ENOENT")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all projects sorted by updatedAt (descending)
+   * @returns Array of project summaries (project + metadata)
+   */
+  async listProjects() {
+    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({
+          project: data.project,
+          taskCount: data.tasks.length,
+          milestoneCount: data.milestones.length
+        });
+      } catch {
+        continue;
+      }
+    }
+    return projects.sort(
+      (a, b) => new Date(b.project.updatedAt).getTime() - new Date(a.project.updatedAt).getTime()
+    );
+  }
+  /**
+   * Search tasks across all projects with filters
+   * @param filters - Search filters
+   * @returns Array of matching tasks with project context
+   */
+  async searchTasks(filters) {
+    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 results = [];
+    for (const file of jsonFiles) {
+      try {
+        const filePath = path3.join(this.storageDir, file);
+        const data = await readJsonFile(filePath);
+        if (filters.projectId && data.project.id !== filters.projectId) {
+          continue;
+        }
+        for (const task of data.tasks) {
+          if (filters.status && task.status !== filters.status) {
+            continue;
+          }
+          if (filters.priority && task.priority !== filters.priority) {
+            continue;
+          }
+          if (filters.assignee && task.assignee !== filters.assignee) {
+            continue;
+          }
+          if (filters.dueBefore && task.dueDate && task.dueDate > filters.dueBefore) {
+            continue;
+          }
+          if (filters.dueAfter && task.dueDate && task.dueDate < filters.dueAfter) {
+            continue;
+          }
+          if (filters.tags && filters.tags.length > 0 && !filters.tags.some((tag) => task.tags.includes(tag))) {
+            continue;
+          }
+          if (filters.searchText && !task.title.toLowerCase().includes(filters.searchText.toLowerCase()) && !task.description.toLowerCase().includes(filters.searchText.toLowerCase())) {
+            continue;
+          }
+          results.push({ task, project: data.project });
+        }
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  }
+};
+var storage = new ProjectStorage();
+
+// src/tools/project-tools.ts
+var ProjectTypeEnum = z.enum(["roadmap", "skill-tree", "kanban"]);
+var ProjectStatusEnum = z.enum(["active", "completed", "archived"]);
+var createProjectTool = {
+  name: "create_project",
+  description: "Create a new project roadmap",
+  inputSchema: z.object({
+    name: z.string().min(1, "Project name is required"),
+    description: z.string(),
+    projectType: ProjectTypeEnum,
+    startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
+    targetDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format")
+  }),
+  async execute(input) {
+    try {
+      const projectInput = {
+        name: input.name,
+        description: input.description,
+        projectType: input.projectType,
+        startDate: input.startDate,
+        targetDate: input.targetDate
+      };
+      const projectData = await storage.createProject(projectInput);
+      return {
+        success: true,
+        data: projectData
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create project"
+      };
+    }
+  }
+};
+var listProjectsTool = {
+  name: "list_projects",
+  description: "List all projects with their task and milestone counts",
+  inputSchema: z.object({}),
+  async execute() {
+    try {
+      const projects = await storage.listProjects();
+      return {
+        success: true,
+        data: projects
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list projects"
+      };
+    }
+  }
+};
+var getProjectTool = {
+  name: "get_project",
+  description: "Get a project by ID with all its data (tasks, tags, milestones)",
+  inputSchema: z.object({
+    projectId: z.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
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get project"
+      };
+    }
+  }
+};
+var updateProjectTool = {
+  name: "update_project",
+  description: "Update an existing project",
+  inputSchema: z.object({
+    projectId: z.string().min(1, "Project ID is required"),
+    name: z.string().min(1).optional(),
+    description: z.string().optional(),
+    projectType: ProjectTypeEnum.optional(),
+    status: ProjectStatusEnum.optional(),
+    startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    targetDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
+  }),
+  async execute(input) {
+    try {
+      const { projectId, ...updateData } = input;
+      if (Object.keys(updateData).length === 0) {
+        return {
+          success: false,
+          error: "At least one field to update is required"
+        };
+      }
+      const updateInput = updateData;
+      const projectData = await storage.updateProject(projectId, updateInput);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${projectId}' not found`
+        };
+      }
+      return {
+        success: true,
+        data: projectData
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update project"
+      };
+    }
+  }
+};
+var deleteProjectTool = {
+  name: "delete_project",
+  description: "Delete a project by ID",
+  inputSchema: z.object({
+    projectId: z.string().min(1, "Project ID is required")
+  }),
+  async execute(input) {
+    try {
+      const deleted = await storage.deleteProject(input.projectId);
+      if (!deleted) {
+        return {
+          success: false,
+          error: `Project with ID '${input.projectId}' not found`
+        };
+      }
+      return {
+        success: true,
+        data: { deleted: true }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete project"
+      };
+    }
+  }
+};
+
+// 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)}`;
+}
+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) {
+    try {
+      const projectData = await storage.readProject(input.projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${input.projectId}' not found`
+        };
+      }
+      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
+      };
+      projectData.tasks.push(task);
+      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: task
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create task"
+      };
+    }
+  }
+};
+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()
+  }),
+  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
+      });
+      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) {
+    try {
+      const projectData = await storage.readProject(input.projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${input.projectId}' not found`
+        };
+      }
+      const task = projectData.tasks.find((t) => t.id === input.taskId);
+      if (!task) {
+        return {
+          success: false,
+          error: `Task with ID '${input.taskId}' not found in project '${input.projectId}'`
+        };
+      }
+      return {
+        success: true,
+        data: task
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get task"
+      };
+    }
+  }
+};
+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) {
+    try {
+      const projectData = await storage.readProject(input.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}'`
+        };
+      }
+      const { projectId, taskId, ...updateData } = input;
+      if (Object.keys(updateData).length === 0) {
+        return {
+          success: false,
+          error: "At least one field to update is required"
+        };
+      }
+      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(input.projectId);
+      const { writeJsonFile: writeJsonFile2 } = await Promise.resolve().then(() => (init_file_helpers(), file_helpers_exports));
+      await writeJsonFile2(filePath, projectData);
+      return {
+        success: true,
+        data: updatedTask
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update task"
+      };
+    }
+  }
+};
+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) {
+    try {
+      const projectData = await storage.readProject(input.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}'`
+        };
+      }
+      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);
+      return {
+        success: true,
+        data: { deleted: true }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete task"
+      };
+    }
+  }
+};
+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) {
+    try {
+      const projectData = await storage.readProject(input.projectId);
+      if (!projectData) {
+        return {
+          success: false,
+          error: `Project with ID '${input.projectId}' not found`
+        };
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const updatedTasks = [];
+      const notFoundIds = [];
+      for (const taskId of input.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 (input.tags && input.tags.length > 0) {
+          switch (input.tagOperation) {
+            case "add":
+              updatedTags = [.../* @__PURE__ */ new Set([...existingTask.tags, ...input.tags])];
+              break;
+            case "remove":
+              updatedTags = existingTask.tags.filter((tag) => !input.tags.includes(tag));
+              break;
+            case "replace":
+            default:
+              updatedTags = input.tags;
+              break;
+          }
+        }
+        const updatedTask = {
+          ...existingTask,
+          ...input.status && { status: input.status },
+          ...input.priority && { priority: input.priority },
+          tags: updatedTags,
+          updatedAt: now,
+          ...input.status === "done" && existingTask.status !== "done" && { completedAt: now },
+          ...input.status && input.status !== "done" && { completedAt: null }
+        };
+        projectData.tasks[taskIndex] = updatedTask;
+        updatedTasks.push(updatedTask);
+      }
+      if (updatedTasks.length === 0) {
+        return {
+          success: false,
+          error: "No tasks were found to update",
+          notFoundIds
+        };
+      }
+      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: {
+          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"
+      };
+    }
+  }
+};
+
+// 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 createTagTool = {
+  name: "create_tag",
+  description: "Create a new tag in a project",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    name: z3.string().min(1, "Tag name is required"),
+    color: z3.string().regex(/^#[0-9A-Fa-f]{6}$/, "Color must be a valid hex code (e.g., #FF5733)"),
+    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"
+      };
+    }
+  }
+};
+var listTagsTool = {
+  name: "list_tags",
+  description: "List all tags in a project",
+  inputSchema: z3.object({
+    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"
+      };
+    }
+  }
+};
+var updateTagTool = {
+  name: "update_tag",
+  description: "Update an existing tag",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    tagId: z3.string().min(1, "Tag ID is required"),
+    name: z3.string().min(1).optional(),
+    color: z3.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+    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"
+      };
+    }
+  }
+};
+var deleteTagTool = {
+  name: "delete_tag",
+  description: "Delete a tag by project ID and tag ID",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    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"
+      };
+    }
+  }
+};
+var getTasksByTagTool = {
+  name: "get_tasks_by_tag",
+  description: "Get all tasks that have a specific tag",
+  inputSchema: z3.object({
+    projectId: z3.string().min(1, "Project ID is required"),
+    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"
+      };
+    }
+  }
+};
+
+// src/tools/web-tools.ts
+init_esm_shims();
+
+// src/web/server.ts
+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);
+function createServer(port = 7860) {
+  const app = express();
+  app.use(express.json());
+  app.get("/api/projects", async (_req, res) => {
+    try {
+      const projects = await storage.listProjects();
+      res.json(projects);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.get("/api/projects/:id", async (req, res) => {
+    try {
+      const project = await storage.readProject(req.params.id);
+      if (!project) {
+        res.status(404).json({ error: "Project not found" });
+        return;
+      }
+      res.json(project);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.get("/api/tasks", async (req, res) => {
+    try {
+      const filters = req.query;
+      const tasks = await storage.searchTasks(filters);
+      res.json(tasks);
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.post("/api/projects", async (req, res) => {
+    try {
+      const project = await storage.createProject(req.body);
+      res.json({ success: true, data: project });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.put("/api/projects", async (req, res) => {
+    try {
+      const { projectId, ...updateData } = req.body;
+      const project = await storage.updateProject(projectId, updateData);
+      res.json({ success: true, data: project });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.delete("/api/projects", async (req, res) => {
+    try {
+      const { projectId } = req.query;
+      await storage.deleteProject(projectId);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  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" });
+        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 });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  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" });
+        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 });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  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" });
+        return;
+      }
+      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
+      if (taskIndex === -1) {
+        res.status(404).json({ error: "Task not found" });
+        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 });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  const distPath = path4.join(__dirname2, "app");
+  app.use(express.static(distPath));
+  app.get("*", (req, res) => {
+    if (req.path.startsWith("/api")) {
+      res.status(404).json({ error: "API not found" });
+      return;
+    }
+    res.sendFile(path4.join(distPath, "index.html"));
+  });
+  const server = app.listen(port, "0.0.0.0", () => {
+    console.log(`Web interface server running at http://0.0.0.0:${port}`);
+  });
+  return server;
+}
+
+// src/tools/web-tools.ts
+var activeServer = null;
+var openWebInterfaceTool = {
+  name: "open_web_interface",
+  description: "Open web visualization interface",
+  parameters: {
+    type: "object",
+    properties: {
+      port: {
+        type: "number",
+        description: "Port to run the web interface on (default: 7860)"
+      }
+    }
+  },
+  async execute(args) {
+    if (activeServer) {
+      return {
+        message: "Web interface is already running",
+        url: `http://localhost:${activeServer.address().port}`
+      };
+    }
+    const port = args.port || 7860;
+    activeServer = createServer(port);
+    return {
+      message: "Web interface started successfully",
+      url: `http://localhost:${port}`
+    };
+  }
+};
+var closeWebInterfaceTool = {
+  name: "close_web_interface",
+  description: "Close web visualization interface",
+  async execute() {
+    if (!activeServer) {
+      return { message: "Web interface is not running" };
+    }
+    return new Promise((resolve) => {
+      activeServer.close(() => {
+        activeServer = null;
+        resolve({ message: "Web interface stopped" });
+      });
+    });
+  }
+};
+
+// src/tools/template-tools.ts
+init_esm_shims();
+import { z as z4 } from "zod";
+import * as path5 from "path";
+import * as fs2 from "fs/promises";
+var TEMPLATES_DIR = path5.join(process.cwd(), "templates");
+async function getTemplateFiles() {
+  try {
+    const files = await fs2.readdir(TEMPLATES_DIR);
+    return files.filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+}
+async function loadTemplate(templateName) {
+  try {
+    const fileName = templateName.endsWith(".json") ? templateName : `${templateName}.json`;
+    const filePath = path5.join(TEMPLATES_DIR, fileName);
+    const content = await fs2.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function generateId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var listTemplatesTool = {
+  name: "list_templates",
+  description: "List all available project templates",
+  inputSchema: z4.object({}),
+  async execute() {
+    try {
+      const templateFiles = await getTemplateFiles();
+      const templates = [];
+      for (const file of templateFiles) {
+        const template = await loadTemplate(file);
+        if (template) {
+          templates.push({
+            name: file.replace(".json", ""),
+            displayName: template.name,
+            description: template.description,
+            projectType: template.projectType,
+            taskCount: template.tasks.length,
+            tagCount: template.tags.length
+          });
+        }
+      }
+      return {
+        success: true,
+        data: templates
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to list templates"
+      };
+    }
+  }
+};
+var getTemplateTool = {
+  name: "get_template",
+  description: "Get detailed information about a specific template",
+  inputSchema: z4.object({
+    templateName: z4.string().min(1, "Template name is required")
+  }),
+  async execute(input) {
+    try {
+      const template = await loadTemplate(input.templateName);
+      if (!template) {
+        return {
+          success: false,
+          error: `Template '${input.templateName}' not found`
+        };
+      }
+      return {
+        success: true,
+        data: {
+          name: template.name,
+          description: template.description,
+          projectType: template.projectType,
+          tasks: template.tasks.map((t) => ({
+            title: t.title,
+            description: t.description,
+            priority: t.priority,
+            tags: t.tags,
+            estimatedHours: t.estimatedHours
+          })),
+          tags: template.tags
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get template"
+      };
+    }
+  }
+};
+var applyTemplateTool = {
+  name: "apply_template",
+  description: "Create a new project from a template",
+  inputSchema: z4.object({
+    templateName: z4.string().min(1, "Template name is required"),
+    projectName: z4.string().min(1, "Project name is required"),
+    description: z4.string().default(""),
+    startDate: z4.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional(),
+    targetDate: z4.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format").optional()
+  }),
+  async execute(input) {
+    try {
+      const template = await loadTemplate(input.templateName);
+      if (!template) {
+        return {
+          success: false,
+          error: `Template '${input.templateName}' not found`
+        };
+      }
+      const projectInput = {
+        name: input.projectName,
+        description: input.description || template.description,
+        projectType: template.projectType,
+        startDate: input.startDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+        targetDate: input.targetDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      };
+      const projectData = await storage.createProject(projectInput);
+      const projectId = projectData.project.id;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const tagNameToId = /* @__PURE__ */ new Map();
+      const tags = [];
+      for (const templateTag of template.tags) {
+        const tag = {
+          id: generateId("tag"),
+          name: templateTag.name,
+          color: templateTag.color,
+          description: "",
+          createdAt: now
+        };
+        tags.push(tag);
+        tagNameToId.set(templateTag.name, tag.id);
+      }
+      const tasks = [];
+      for (const templateTask of template.tasks) {
+        const taskTagIds = templateTask.tags.map((tagName) => tagNameToId.get(tagName)).filter((id) => id !== void 0);
+        const task = {
+          id: generateId("task"),
+          projectId,
+          title: templateTask.title,
+          description: templateTask.description,
+          status: "todo",
+          priority: templateTask.priority,
+          tags: taskTagIds,
+          dueDate: null,
+          assignee: null,
+          createdAt: now,
+          updatedAt: now,
+          completedAt: null
+        };
+        tasks.push(task);
+      }
+      projectData.tags = tags;
+      projectData.tasks = tasks;
+      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);
+      return {
+        success: true,
+        data: {
+          project: projectData.project,
+          taskCount: tasks.length,
+          tagCount: tags.length,
+          tasksCreated: tasks.map((t) => ({
+            id: t.id,
+            title: t.title,
+            priority: t.priority
+          })),
+          tagsCreated: tags.map((t) => ({
+            id: t.id,
+            name: t.name,
+            color: t.color
+          }))
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to apply template"
+      };
+    }
+  }
+};
+
+// src/resources/index.ts
+init_esm_shims();
+
+// src/resources/project-resources.ts
+init_esm_shims();
+var projectResources = [
+  {
+    uri: "roadmap://projects",
+    name: "Project List",
+    mimeType: "application/json",
+    description: "Returns a list of all projects with basic metadata"
+  },
+  {
+    uri: "roadmap://project/{projectId}",
+    name: "Project Details",
+    mimeType: "application/json",
+    description: "Returns detailed information about a specific project including tasks, milestones, and tags"
+  },
+  {
+    uri: "roadmap://project/{projectId}/tasks",
+    name: "Project Tasks",
+    mimeType: "application/json",
+    description: "Returns all tasks for a specific project"
+  },
+  {
+    uri: "roadmap://project/{projectId}/progress",
+    name: "Project Progress",
+    mimeType: "application/json",
+    description: "Returns progress statistics for a specific project"
+  }
+];
+var RESOURCE_PATTERNS = {
+  projectList: /^roadmap:\/\/projects$/,
+  projectDetails: /^roadmap:\/\/project\/([^/]+)$/,
+  projectTasks: /^roadmap:\/\/project\/([^/]+)\/tasks$/,
+  projectProgress: /^roadmap:\/\/project\/([^/]+)\/progress$/
+};
+async function handleResourceRequest(uri) {
+  if (RESOURCE_PATTERNS.projectList.test(uri)) {
+    return await getProjectListResource(uri);
+  }
+  const projectDetailsMatch = uri.match(RESOURCE_PATTERNS.projectDetails);
+  if (projectDetailsMatch && !uri.includes("/tasks") && !uri.includes("/progress")) {
+    const projectId = projectDetailsMatch[1];
+    return await getProjectDetailsResource(uri, projectId);
+  }
+  const projectTasksMatch = uri.match(RESOURCE_PATTERNS.projectTasks);
+  if (projectTasksMatch) {
+    const projectId = projectTasksMatch[1];
+    return await getProjectTasksResource(uri, projectId);
+  }
+  const projectProgressMatch = uri.match(RESOURCE_PATTERNS.projectProgress);
+  if (projectProgressMatch) {
+    const projectId = projectProgressMatch[1];
+    return await getProjectProgressResource(uri, projectId);
+  }
+  return null;
+}
+async function getProjectListResource(uri) {
+  const projects = await storage.listProjects();
+  const data = {
+    projects: projects.map((p) => ({
+      id: p.project.id,
+      name: p.project.name,
+      description: p.project.description,
+      status: p.project.status,
+      projectType: p.project.projectType,
+      taskCount: p.taskCount,
+      milestoneCount: p.milestoneCount,
+      updatedAt: p.project.updatedAt
+    })),
+    totalCount: projects.length
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function getProjectDetailsResource(uri, projectId) {
+  const projectData = await storage.readProject(projectId);
+  if (!projectData) {
+    return null;
+  }
+  const data = {
+    project: projectData.project,
+    milestones: projectData.milestones,
+    tasks: projectData.tasks,
+    tags: projectData.tags,
+    stats: {
+      taskCount: projectData.tasks.length,
+      milestoneCount: projectData.milestones.length,
+      tagCount: projectData.tags.length,
+      completedTasks: projectData.tasks.filter((t) => t.status === "done").length,
+      inProgressTasks: projectData.tasks.filter((t) => t.status === "in-progress").length
+    }
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function getProjectTasksResource(uri, projectId) {
+  const projectData = await storage.readProject(projectId);
+  if (!projectData) {
+    return null;
+  }
+  const tasksByStatus = {
+    todo: projectData.tasks.filter((t) => t.status === "todo"),
+    inProgress: projectData.tasks.filter((t) => t.status === "in-progress"),
+    review: projectData.tasks.filter((t) => t.status === "review"),
+    done: projectData.tasks.filter((t) => t.status === "done")
+  };
+  const data = {
+    projectId,
+    projectName: projectData.project.name,
+    tasks: projectData.tasks,
+    tasksByStatus,
+    summary: {
+      total: projectData.tasks.length,
+      todo: tasksByStatus.todo.length,
+      inProgress: tasksByStatus.inProgress.length,
+      review: tasksByStatus.review.length,
+      done: tasksByStatus.done.length
+    }
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+async function getProjectProgressResource(uri, projectId) {
+  const projectData = await storage.readProject(projectId);
+  if (!projectData) {
+    return null;
+  }
+  const tasks = projectData.tasks;
+  const totalTasks = tasks.length;
+  const completedTasks = tasks.filter((t) => t.status === "done").length;
+  const inProgressTasks = tasks.filter((t) => t.status === "in-progress").length;
+  const reviewTasks = tasks.filter((t) => t.status === "review").length;
+  const todoTasks = tasks.filter((t) => t.status === "todo").length;
+  const completionPercentage = totalTasks > 0 ? Math.round(completedTasks / totalTasks * 100) : 0;
+  const milestones = projectData.milestones;
+  const completedMilestones = milestones.filter((m) => m.completedAt !== null).length;
+  const milestoneProgress = milestones.length > 0 ? Math.round(completedMilestones / milestones.length * 100) : 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const overdueTasks = tasks.filter(
+    (t) => t.dueDate && t.dueDate < now && t.status !== "done"
+  );
+  const priorityBreakdown = {
+    critical: tasks.filter((t) => t.priority === "critical").length,
+    high: tasks.filter((t) => t.priority === "high").length,
+    medium: tasks.filter((t) => t.priority === "medium").length,
+    low: tasks.filter((t) => t.priority === "low").length
+  };
+  const data = {
+    projectId,
+    projectName: projectData.project.name,
+    projectStatus: projectData.project.status,
+    dates: {
+      startDate: projectData.project.startDate,
+      targetDate: projectData.project.targetDate,
+      daysRemaining: calculateDaysRemaining(projectData.project.targetDate)
+    },
+    taskProgress: {
+      total: totalTasks,
+      completed: completedTasks,
+      inProgress: inProgressTasks,
+      review: reviewTasks,
+      todo: todoTasks,
+      completionPercentage
+    },
+    milestoneProgress: {
+      total: milestones.length,
+      completed: completedMilestones,
+      percentage: milestoneProgress
+    },
+    overdueTasks: {
+      count: overdueTasks.length,
+      tasks: overdueTasks.map((t) => ({
+        id: t.id,
+        title: t.title,
+        dueDate: t.dueDate,
+        status: t.status
+      }))
+    },
+    priorityBreakdown,
+    lastUpdated: projectData.project.updatedAt
+  };
+  return {
+    uri,
+    mimeType: "application/json",
+    text: JSON.stringify(data, null, 2)
+  };
+}
+function calculateDaysRemaining(targetDate) {
+  const target = new Date(targetDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffTime = target.getTime() - now.getTime();
+  const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+  return diffDays > 0 ? diffDays : null;
+}
+function getAllResources() {
+  return projectResources;
+}
+
+// src/prompts/index.ts
+init_esm_shims();
+
+// src/prompts/project-prompts.ts
+init_esm_shims();
+var projectPrompts = [
+  {
+    name: "projectPlanningPrompt",
+    description: "Helps users plan a new project with structured guidance",
+    arguments: [
+      {
+        name: "projectType",
+        description: "Type of project (roadmap, skill-tree, kanban)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "taskManagementPrompt",
+    description: "Helps users manage and organize tasks effectively",
+    arguments: [
+      {
+        name: "projectId",
+        description: "ID of the project to manage tasks for",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "roadmapOverviewPrompt",
+    description: "Shows a comprehensive overview of the roadmap",
+    arguments: []
+  },
+  {
+    name: "milestoneReviewPrompt",
+    description: "Helps review and evaluate project milestones",
+    arguments: [
+      {
+        name: "projectId",
+        description: "ID of the project to review milestones for",
+        required: false
+      }
+    ]
+  }
+];
+function getProjectPlanningPrompt(projectType) {
+  const typeContext = projectType ? `You are planning a ${projectType} project.` : "You are planning a new project.";
+  return {
+    description: "Project Planning Assistant",
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `${typeContext}
+
+I will help you plan your project step by step. Let's start by defining the key aspects:
+
+## Step 1: Project Definition
+- What is the name of your project?
+- What is the main goal or objective?
+- Who is the target audience or beneficiary?
+
+## Step 2: Scope and Timeline
+- What are the start and target completion dates?
+- What are the major deliverables?
+- What is explicitly out of scope?
+
+## Step 3: Key Milestones
+Identify 3-5 major milestones that mark significant progress:
+- Milestone 1: [Name] - Target Date
+- Milestone 2: [Name] - Target Date
+- Milestone 3: [Name] - Target Date
+
+## Step 4: Initial Tasks
+List the first 5-10 tasks to get started:
+- Task name and brief description
+- Priority level (low, medium, high, critical)
+- Estimated completion time
+
+## Step 5: Resources and Tags
+- What categories or tags will help organize this project?
+- Are there any specific resources, tools, or people needed?
+
+## Example
+Here's a simple example for a "Learn TypeScript" skill-tree project:
+
+**Project**: TypeScript Mastery
+**Goal**: Become proficient in TypeScript for web development
+**Timeline**: 3 months (Jan 1 - Mar 31)
+
+**Milestones**:
+1. Complete basic syntax (Week 2)
+2. Build first TypeScript app (Week 6)
+3. Master advanced types (Week 10)
+4. Complete final project (Week 12)
+
+**Initial Tasks**:
+1. Set up TypeScript environment (high priority)
+2. Complete "Hello World" tutorial (medium priority)
+3. Study type annotations (high priority)
+4. Practice with interfaces (medium priority)
+
+Please share your project details, and I'll help you refine the plan!`
+        }
+      }
+    ]
+  };
+}
+function getTaskManagementPrompt(projectId) {
+  const projectContext = projectId ? `Managing tasks for project: ${projectId}` : "Managing tasks across all projects";
+  return {
+    description: "Task Management Assistant",
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `${projectContext}
+
+I'll help you manage your tasks effectively. Here are the key areas we can work on:
+
+## Task Organization
+
+### Current Status Review
+Let's review tasks by status:
+- **Todo**: Tasks waiting to be started
+- **In Progress**: Tasks currently being worked on
+- **Review**: Tasks completed and awaiting review
+- **Done**: Completed tasks
+
+### Priority Management
+Tasks should be prioritized as:
+- **Critical**: Blockers, urgent deadlines, essential functionality
+- **High**: Important features, near-term deadlines
+- **Medium**: Standard work, nice-to-have features
+- **Low**: Backlog items, future improvements
+
+## Task Actions
+
+### Creating New Tasks
+When creating a task, include:
+- Clear, actionable title
+- Detailed description with acceptance criteria
+- Priority level
+- Due date (if applicable)
+- Assignee (if applicable)
+- Relevant tags
+
+### Updating Tasks
+Common updates include:
+- Status changes (todo \u2192 in progress \u2192 review \u2192 done)
+- Priority adjustments
+- Due date modifications
+- Adding comments or notes
+
+### Batch Operations
+You can perform actions on multiple tasks:
+- Update status for multiple tasks
+- Reassign tasks
+- Apply tags to multiple tasks
+
+## Best Practices
+
+1. **Keep tasks small**: Break large work into manageable pieces
+2. **Write clear titles**: Use action verbs (e.g., "Implement", "Fix", "Update")
+3. **Set realistic due dates**: Account for dependencies and blockers
+4. **Review regularly**: Check overdue tasks and adjust priorities
+5. **Use tags consistently**: Create a tagging convention and stick to it
+
+## Example Workflow
+
+**Morning Routine**:
+1. Review overdue tasks
+2. Check what's in progress
+3. Prioritize today's work
+4. Update task statuses
+
+**Weekly Review**:
+1. Review completed tasks
+2. Assess progress toward milestones
+3. Reprioritize upcoming work
+4. Identify blockers
+
+What would you like to work on? You can:
+- View tasks by status
+- Create new tasks
+- Update existing tasks
+- Search for specific tasks
+- Get an overview of task distribution`
+        }
+      }
+    ]
+  };
+}
+function getRoadmapOverviewPrompt() {
+  return {
+    description: "Roadmap Overview Assistant",
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `Welcome to your Roadmap Overview!
+
+I'll help you get a comprehensive view of all your projects and their progress. Here's what we can explore:
+
+## Dashboard Overview
+
+### Project Summary
+- Total number of projects
+- Projects by status (active, completed, archived)
+- Projects by type (roadmap, skill-tree, kanban)
+- Recently updated projects
+
+### Task Overview
+- Total tasks across all projects
+- Tasks by status (todo, in progress, review, done)
+- Overdue tasks requiring attention
+- Tasks by priority level
+
+### Progress Metrics
+- Overall completion percentage
+- Milestones completed vs. total
+- Average tasks per project
+- Upcoming deadlines
+
+## Project Health Indicators
+
+### Green (Healthy)
+- On track with timeline
+- No overdue critical tasks
+- Regular progress being made
+
+### Yellow (Attention Needed)
+- Some tasks overdue but not critical
+- Approaching deadline
+- Tasks stuck in review
+
+### Red (Requires Action)
+- Critical tasks overdue
+- Missed milestones
+- No recent progress
+
+## Navigation Guide
+
+### Viewing Projects
+- List all projects with key metrics
+- Filter by status or type
+- Sort by various criteria (updated, created, name)
+
+### Drilling Down
+- View specific project details
+- See all tasks for a project
+- Check milestone progress
+- Review tag usage
+
+### Taking Action
+- Identify projects needing attention
+- Find overdue tasks
+- Review completed work
+- Plan upcoming work
+
+## Example Queries
+
+**"Show me all active projects"**
+Lists projects with status = active, sorted by most recently updated
+
+**"What tasks are overdue?"**
+Shows all tasks where due date < today and status != done
+
+**"Which projects are at risk?"**
+Identifies projects with overdue critical/high priority tasks
+
+**"Show my progress this week"**
+Displays tasks completed in the last 7 days
+
+## Quick Actions
+
+1. **Review Overdue Items**: Check what needs immediate attention
+2. **Celebrate Wins**: Review recently completed tasks
+3. **Plan Ahead**: Look at upcoming milestones and deadlines
+4. **Clean Up**: Archive completed projects
+
+What would you like to see first? I can show you:
+- A summary of all projects
+- Overdue tasks across all projects
+- Progress statistics
+- Specific project details`
+        }
+      }
+    ]
+  };
+}
+function getMilestoneReviewPrompt(projectId) {
+  const projectContext = projectId ? `Reviewing milestones for project: ${projectId}` : "Reviewing milestones across all projects";
+  return {
+    description: "Milestone Review Assistant",
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `${projectContext}
+
+I'll help you review and evaluate your project milestones. Milestones are key checkpoints that help track significant progress.
+
+## Milestone Review Framework
+
+### What is a Milestone?
+A milestone represents a significant achievement or checkpoint in your project:
+- Major deliverable completion
+- Phase transition
+- Key decision point
+- External deadline
+
+### Milestone Status Types
+- **Not Started**: Target date in future, no work completed
+- **In Progress**: Work ongoing toward milestone
+- **At Risk**: May not meet target date
+- **Completed**: Achieved and marked complete
+- **Missed**: Target date passed without completion
+
+## Review Checklist
+
+### For Each Milestone, Ask:
+
+1. **Relevance**
+   - Is this milestone still relevant to project goals?
+   - Does it represent meaningful progress?
+   - Are the success criteria clear?
+
+2. **Timeline**
+   - Is the target date realistic?
+   - Are there dependencies blocking progress?
+   - Do we need to adjust the date?
+
+3. **Progress**
+   - What percentage complete is this milestone?
+   - Which tasks contribute to this milestone?
+   - Are there blockers or risks?
+
+4. **Completion Criteria**
+   - What defines "complete" for this milestone?
+   - Are there acceptance criteria?
+   - Who needs to sign off?
+
+## Milestone Management Actions
+
+### Creating Milestones
+Best practices for new milestones:
+- Use clear, descriptive names
+- Set realistic target dates
+- Define completion criteria
+- Link related tasks
+
+### Updating Milestones
+Common updates during review:
+- Adjust target dates based on progress
+- Update descriptions to reflect scope changes
+- Mark completed when criteria met
+- Archive obsolete milestones
+
+### Tracking Progress
+Ways to monitor milestone health:
+- Percentage of linked tasks complete
+- Time remaining vs. work remaining
+- Risk assessment (low/medium/high)
+- Dependency status
+
+## Example Milestone Review
+
+**Project**: Website Redesign
+**Milestone**: Design Phase Complete
+**Target Date**: March 15, 2024
+
+**Review Questions**:
+- \u2713 Relevance: Still critical path item
+- \u26A0 Timeline: 5 days remaining, 60% complete
+- Progress: 3 of 5 design tasks done
+- Risks: User research taking longer than expected
+
+**Decision**: Extend target date by 3 days, add resources to user research
+
+## Review Schedule Recommendations
+
+### Weekly
+- Quick check of upcoming milestones (next 2 weeks)
+- Identify any at-risk items
+
+### Monthly
+- Full review of all active milestones
+- Adjust timelines as needed
+- Celebrate completed milestones
+
+### Quarterly
+- Strategic review of milestone alignment
+- Archive completed project milestones
+- Plan next quarter's milestones
+
+## Metrics to Track
+
+- **Milestone Completion Rate**: % of milestones completed on time
+- **Average Delay**: How often and by how much dates slip
+- **Scope Changes**: Number of milestones added/removed
+- **Predictability**: Variance between planned and actual dates
+
+What would you like to do?
+- Review milestones for a specific project
+- Identify at-risk milestones
+- Plan new milestones
+- Analyze milestone performance
+- Update existing milestones`
+        }
+      }
+    ]
+  };
+}
+function getPromptByName(name, args) {
+  switch (name) {
+    case "projectPlanningPrompt":
+      return getProjectPlanningPrompt(args?.projectType);
+    case "taskManagementPrompt":
+      return getTaskManagementPrompt(args?.projectId);
+    case "roadmapOverviewPrompt":
+      return getRoadmapOverviewPrompt();
+    case "milestoneReviewPrompt":
+      return getMilestoneReviewPrompt(args?.projectId);
+    default:
+      return null;
+  }
+}
+function getAllPrompts() {
+  return projectPrompts;
+}
+
+// src/server.ts
+var allTools = [
+  createProjectTool,
+  listProjectsTool,
+  getProjectTool,
+  updateProjectTool,
+  deleteProjectTool,
+  createTaskTool,
+  listTasksTool,
+  getTaskTool,
+  updateTaskTool,
+  deleteTaskTool,
+  batchUpdateTasksTool,
+  createTagTool,
+  listTagsTool,
+  updateTagTool,
+  deleteTagTool,
+  getTasksByTagTool,
+  openWebInterfaceTool,
+  closeWebInterfaceTool
+];
+var toolMap = new Map(allTools.map((tool) => [tool.name, tool]));
+function createServer2() {
+  const server = new Server(
+    {
+      name: "roadmap-skill",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async (_request) => {
+    return {
+      tools: allTools.map((tool) => {
+        const inputSchema = tool.parameters || tool.inputSchema;
+        return {
+          name: tool.name,
+          description: tool.description,
+          inputSchema: inputSchema || { type: "object" }
+        };
+      })
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const tool = toolMap.get(name);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    try {
+      const result = await tool.execute(args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Tool execution failed: ${errorMessage}`);
+    }
+  });
+  server.setRequestHandler(ListResourcesRequestSchema, async (_request) => {
+    const resources = getAllResources();
+    return { resources };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const resourceContent = await handleResourceRequest(uri);
+    if (!resourceContent) {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+    return {
+      contents: [resourceContent]
+    };
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async (_request) => {
+    const prompts = getAllPrompts();
+    return { prompts };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const promptResult = getPromptByName(name, args);
+    if (!promptResult) {
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    return promptResult;
+  });
+  return server;
+}
+async function startServer() {
+  const server = createServer2();
+  const transport = new StdioServerTransport();
+  console.error("Roadmap Skill MCP Server starting...");
+  try {
+    await server.connect(transport);
+    console.error("Roadmap Skill MCP Server connected and ready");
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    throw error;
+  }
+}
+
+// src/index.ts
+async function main() {
+  process.on("SIGINT", () => {
+    console.error("Received SIGINT, shutting down gracefully...");
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    console.error("Received SIGTERM, shutting down gracefully...");
+    process.exit(0);
+  });
+  process.on("uncaughtException", (error) => {
+    console.error("Uncaught exception:", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason);
+    process.exit(1);
+  });
+  try {
+    await startServer();
+  } catch (error) {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.js.map