roadmap-skill 0.1.4 → 0.2.3

package/dist/index.js

@@ -276,6 +276,9 @@ var ProjectStorage = class {
           if (filters.searchText && !task.title.toLowerCase().includes(filters.searchText.toLowerCase()) && !task.description.toLowerCase().includes(filters.searchText.toLowerCase())) {
             continue;
           }
+          if (filters.includeCompleted === false && task.status === "done") {
+            continue;
+          }
           results.push({ task, project: data.project });
         }
       } catch {
@@ -508,7 +511,8 @@ var listTasksTool = {
     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()
+    dueAfter: z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    includeCompleted: z2.boolean().optional()
   }),
   async execute(input) {
     try {
@@ -519,7 +523,8 @@ var listTasksTool = {
         tags: input.tags,
         assignee: input.assignee,
         dueBefore: input.dueBefore,
-        dueAfter: input.dueAfter
+        dueAfter: input.dueAfter,
+        includeCompleted: input.includeCompleted
       });
       return {
         success: true,
@@ -706,12 +711,13 @@ var batchUpdateTasksTool = {
         const existingTask = projectData.tasks[taskIndex];
         let updatedTags = existingTask.tags;
         if (input.tags && input.tags.length > 0) {
+          const existingTags = existingTask.tags || [];
           switch (input.tagOperation) {
             case "add":
-              updatedTags = [.../* @__PURE__ */ new Set([...existingTask.tags, ...input.tags])];
+              updatedTags = [.../* @__PURE__ */ new Set([...existingTags, ...input.tags])];
               break;
             case "remove":
-              updatedTags = existingTask.tags.filter((tag) => !input.tags.includes(tag));
+              updatedTags = existingTags.filter((tag) => !input.tags.includes(tag));
               break;
             case "replace":
             default:
@@ -1019,170 +1025,205 @@ init_esm_shims();
 import express from "express";
 import * as path4 from "path";
 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;
+  return new Promise((resolve, reject) => {
+    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 });
       }
-      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;
+    });
+    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 });
       }
-      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;
+    });
+    app.get("/api/tasks", async (req, res) => {
+      try {
+        const filters = { ...req.query };
+        if (filters.includeCompleted !== void 0) {
+          filters.includeCompleted = filters.includeCompleted === "true";
+        }
+        const tasks = await storage.searchTasks(filters);
+        res.json(tasks);
+      } catch (error) {
+        res.status(500).json({ error: error.message });
       }
-      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-      if (taskIndex === -1) {
-        res.status(404).json({ error: "Task not found" });
-        return;
+    });
+    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 });
       }
-      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" });
+    });
+    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(process.cwd(), "dist", "web", "app");
+    app.use(express.static(distPath));
+    app.get("*", (req, res) => {
+      if (req.path.startsWith("/api")) {
+        res.status(404).json({ error: "API not found" });
         return;
       }
-      const taskIndex = projectData.tasks.findIndex((t) => t.id === taskId);
-      if (taskIndex === -1) {
-        res.status(404).json({ error: "Task not found" });
+      res.sendFile(path4.join(distPath, "index.html"));
+    });
+    const server = app.listen(port, "127.0.0.1");
+    server.once("listening", () => {
+      console.log(`Web interface server running at http://localhost:${port}`);
+      resolve(server);
+    });
+    server.once("error", (error) => {
+      if (error.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use`));
         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(process.cwd(), "dist", "web", "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}`);
+      reject(error);
+    });
   });
-  return server;
 }
 
 // src/tools/web-tools.ts
 import open from "open";
 var activeServer = null;
+var activePort = null;
+function getServerPort(server) {
+  const address = server.address();
+  if (address && typeof address === "object" && "port" in address) {
+    return typeof address.port === "number" ? address.port : null;
+  }
+  return null;
+}
+async function closeServer(server) {
+  await new Promise((resolve, reject) => {
+    server.close((error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+    const forceCloseServer = server;
+    forceCloseServer.closeIdleConnections?.();
+    forceCloseServer.closeAllConnections?.();
+  });
+}
 async function openBrowser(url) {
   try {
     await open(url);
@@ -1203,20 +1244,34 @@ var openWebInterfaceTool = {
     }
   },
   async execute(args) {
+    const requestedPort = args.port || 7860;
     if (activeServer) {
+      const runningPort = getServerPort(activeServer) ?? activePort;
+      if (runningPort !== requestedPort) {
+        throw new Error(`Web interface is already running on port ${runningPort ?? "unknown"}. Please close it before opening a different port.`);
+      }
+      const url2 = `http://localhost:${runningPort ?? requestedPort}`;
+      await openBrowser(url2);
       return {
         message: "Web interface is already running",
-        url: `http://localhost:${activeServer.address().port}`
+        url: url2
       };
     }
-    const port = args.port || 7860;
-    activeServer = createServer(port);
-    const url = `http://localhost:${port}`;
-    void openBrowser(url);
-    return {
-      message: "Web interface started successfully and opened in browser",
-      url
-    };
+    const url = `http://localhost:${requestedPort}`;
+    try {
+      activeServer = await createServer(requestedPort);
+      activePort = requestedPort;
+      await openBrowser(url);
+      return {
+        message: "Web interface started successfully and opened in browser",
+        url
+      };
+    } catch (error) {
+      activeServer = null;
+      activePort = null;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to start web interface: ${errorMessage}`);
+    }
   }
 };
 var closeWebInterfaceTool = {
@@ -1230,12 +1285,15 @@ var closeWebInterfaceTool = {
     if (!activeServer) {
       return { message: "Web interface is not running" };
     }
-    return new Promise((resolve) => {
-      activeServer.close(() => {
-        activeServer = null;
-        resolve({ message: "Web interface stopped" });
-      });
-    });
+    try {
+      await closeServer(activeServer);
+      activeServer = null;
+      activePort = null;
+      return { message: "Web interface stopped" };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to stop web interface: ${errorMessage}`);
+    }
   }
 };
 
@@ -1648,412 +1706,335 @@ init_esm_shims();
 init_esm_shims();
 var projectPrompts = [
   {
-    name: "projectPlanningPrompt",
-    description: "Helps users plan a new project with structured guidance",
+    name: "recommendNextTasks",
+    description: "Intelligently recommend the next priority tasks based on urgency, due dates, and project status",
     arguments: [
       {
-        name: "projectType",
-        description: "Type of project (roadmap, skill-tree, kanban)",
+        name: "projectId",
+        description: "Specific project ID (optional; if not provided, analyze all projects)",
+        required: false
+      },
+      {
+        name: "limit",
+        description: "Number of tasks to recommend (default: 3)",
         required: false
       }
     ]
   },
   {
-    name: "taskManagementPrompt",
-    description: "Helps users manage and organize tasks effectively",
+    name: "autoPrioritize",
+    description: "Automatically analyze tasks and intelligently adjust priorities, considering due dates, dependencies, and project importance",
     arguments: [
       {
         name: "projectId",
-        description: "ID of the project to manage tasks for",
+        description: "Specific project ID (optional; if not provided, analyze all projects)",
         required: false
       }
     ]
   },
   {
-    name: "roadmapOverviewPrompt",
-    description: "Shows a comprehensive overview of the roadmap",
-    arguments: []
+    name: "enhanceTaskDetails",
+    description: "Intelligently enhance task details, including description, acceptance criteria, subtasks, and required resources",
+    arguments: [
+      {
+        name: "taskId",
+        description: "Task ID to be enhanced",
+        required: true
+      }
+    ]
   },
   {
-    name: "milestoneReviewPrompt",
-    description: "Helps review and evaluate project milestones",
+    name: "quickCapture",
+    description: "Quickly capture ideas/tasks, auto-categorize and suggest priorities",
     arguments: [
+      {
+        name: "idea",
+        description: "Idea or task description to be captured",
+        required: true
+      },
       {
         name: "projectId",
-        description: "ID of the project to review milestones for",
+        description: "Target project ID (optional)",
         required: false
       }
     ]
   }
 ];
-function getProjectPlanningPrompt(projectType) {
-  const typeContext = projectType ? `You are planning a ${projectType} project.` : "You are planning a new project.";
+function getRecommendNextTasksPrompt(projectId, limit) {
+  const context = projectId ? `Analyze tasks for project ${projectId}` : "Analyze tasks for all active projects";
+  const taskLimit = limit ? parseInt(limit, 10) : 3;
   return {
-    description: "Project Planning Assistant",
+    description: "Intelligent Task Recommendation 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!`
+          text: `${context}, please recommend the ${taskLimit} tasks I should prioritize next.
+
+## Recommendation Logic (sorted by priority):
+
+### 1. Urgent and Important (Critical priority + Near due date)
+- Critical tasks due today or tomorrow
+- Overdue high-priority tasks
+
+### 2. High-Value Tasks (High priority + Clear due date)
+- High priority tasks due this week
+- Critical path tasks blocking other work
+
+### 3. Quick Wins (Medium priority + Short estimated time)
+- Medium tasks completable in 1-2 hours
+- Tasks that can significantly boost project progress
+
+### 4. Planned Work
+- Tasks marked "in-progress" but not yet completed
+- Normal priority tasks due soon
+
+## Please perform the following steps:
+
+1. **List all pending tasks** (status = todo or in-progress)
+2. **Filter high-priority tasks**: critical and high
+3. **Check due dates**: Identify tasks due soon or overdue
+4. **Analyze blocking relationships**: Identify tasks blocking others
+5. **Generate recommendation list**: Provide ${taskLimit} tasks to prioritize with reasons
+
+## Output Format:
+
+### Immediate Action (Critical)
+1. **Task Name** (Project Name)
+   - Reason: [Why this task is most urgent]
+   - Suggested Action: [What specifically to do]
+
+### Today's Focus (High)
+2. **Task Name** (Project Name)
+   - Reason: [Why this task is important]
+   - Suggested Action: [What specifically to do]
+
+### Follow-up
+3. **Task Name** (Project Name)
+   - Reason: [Why this should be done next]
+   - Suggested Action: [What specifically to do]
+
+Please use the list_tasks tool to fetch task data, then provide intelligent recommendations.
+
+## Important Reminder
+When you start working on recommended tasks, please:
+1. Use update_task to set task status to in-progress
+2. After completing the task, use update_task to set status to done
+3. If blocked or have issues, document in description and update status to review
+
+Keep task status synchronized with actual progress!`
         }
       }
     ]
   };
 }
-function getTaskManagementPrompt(projectId) {
-  const projectContext = projectId ? `Managing tasks for project: ${projectId}` : "Managing tasks across all projects";
+function getAutoPrioritizePrompt(projectId) {
+  const context = projectId ? `Analyze task priorities for project ${projectId}` : "Analyze task priorities for all projects";
   return {
-    description: "Task Management Assistant",
+    description: "Intelligent Priority Optimization 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`
+          text: `${context}, please automatically analyze and suggest priority adjustments.
+
+## Priority Adjustment Rules:
+
+### Conditions to Upgrade to Critical:
+- [ ] Due within 48 hours and not completed
+- [ ] Blocking other high/critical tasks
+- [ ] On project critical path and behind schedule
+- [ ] Has external dependencies (e.g., clients, partners) and time is tight
+
+### Conditions to Upgrade to High:
+- [ ] Due within 1 week
+- [ ] Prerequisite for important milestone
+- [ ] Stuck in "in-progress" state for too long (over 3 days)
+- [ ] Affects work of multiple team members
+
+### Conditions to Downgrade to Medium/Low:
+- [ ] Due date is far away (>2 weeks) and no dependencies
+- [ ] "Nice to have" feature rather than core functionality
+- [ ] Not needed in current phase, can be postponed
+
+### Other Considerations:
+- **Overall project progress**: Tasks for behind-schedule projects should be prioritized higher
+- **Resource availability**: If resources are tight, focus on highest priority
+- **Risk factors**: High-risk tasks should be addressed earlier
+
+## Please perform the following steps:
+
+1. **Get all tasks**: Use list_tasks to fetch task list
+2. **Analyze each task**:
+   - Check gap between due date and current date
+   - Identify task dependency relationships
+   - Evaluate overall project health
+3. **Generate adjustment suggestions**: List tasks needing priority changes with reasons
+4. **Batch update**: Use batch_update_tasks to execute priority adjustments
+
+## Output Format:
+
+### Suggested Upgrade to Critical
+| Task | Current Priority | Suggested Priority | Reason |
+|------|-----------------|-------------------|--------|
+| XXX | high \u2192 critical | Due tomorrow |
+
+### Suggested Upgrade to High
+| Task | Current Priority | Suggested Priority | Reason |
+|------|-----------------|-------------------|--------|
+| XXX | medium \u2192 high | Blocking follow-up tasks |
+
+### Suggested Downgrade
+| Task | Current Priority | Suggested Priority | Reason |
+|------|-----------------|-------------------|--------|
+| XXX | high \u2192 medium | Can be postponed |
+
+### Keep Unchanged (Priorities are reasonable)
+- List tasks with reasonable priority settings
+
+Please provide analysis results, then execute batch update after user confirmation.`
         }
       }
     ]
   };
 }
-function getRoadmapOverviewPrompt() {
+function getEnhanceTaskDetailsPrompt(taskId) {
   return {
-    description: "Roadmap Overview Assistant",
+    description: "Task Detail Enhancement 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
+          text: `Please help me enhance the details for task ${taskId}.
+
+## Enhancement Content:
+
+### 1. Detailed Description
+- Specific content and background of the task
+- Why this task needs to be done
+- Expected business or technical value
+
+### 2. Acceptance Criteria (Definition of Done)
+List clear completion standards, for example:
+- [ ] Feature implemented and locally tested
+- [ ] Code passes Code Review
+- [ ] Related documentation updated
+- [ ] Unit test coverage > 80%
+
+### 3. Technical/Implementation Details
+- Tech stack or modules involved
+- Files that may need modification
+- Potential challenges or considerations
+
+### 4. Related Resources
+- Related documentation links
+- Reference implementations or example code
+- People to consult
+
+### 5. Subtask Suggestions (if needed)
+If the task is complex, suggest breaking it down:
+- Subtask 1: ...
+- Subtask 2: ...
+- Subtask 3: ...
+
+## Please perform the following steps:
+
+1. **Get task info**: Use get_task to view current task details
+2. **Get project context**: Use get_project to understand project background
+3. **Analyze task type**:
+   - If development task: Add technical details, code locations
+   - If design task: Add design specs, review criteria
+   - If documentation task: Add doc structure, references
+   - If testing task: Add test scenarios, coverage scope
+4. **Generate enhancement content**: Use update_task to update task description
+
+## Updated task should include:
+
+\`\`\`
+## Background
+[Task background and purpose]
+
+## Acceptance Criteria
+- [ ] [Standard 1]
+- [ ] [Standard 2]
+- [ ] [Standard 3]
+
+## Technical Details
+- Modules: [module name]
+- Key files: [file path]
+- Notes: [important reminders]
+
+## Related Resources
+- Documentation: [link]
+- References: [link]
+\`\`\`
+
+Please fetch task info first, then provide detailed enhancement suggestions.`
+        }
+      }
+    ]
+  };
+}
+function getQuickCapturePrompt(idea, projectId) {
+  const projectContext = projectId ? `Add to project ${projectId}` : "Auto-select the most suitable project";
+  return {
+    description: "Quick Capture Assistant",
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `I want to quickly capture an idea/task: "${idea}"
 
-### Red (Requires Action)
-- Critical tasks overdue
-- Missed milestones
-- No recent progress
+${projectContext}
 
-## Navigation Guide
+## Please help me complete the following steps:
 
-### Viewing Projects
-- List all projects with key metrics
-- Filter by status or type
-- Sort by various criteria (updated, created, name)
+### 1. Task Information Extraction
+Extract from description:
+- **Task Title**: Concise and clear title (start with verb)
+- **Task Description**: Add context and details
+- **Task Type**: bug / feature / refactor / docs / chore
+- **Estimated Priority**: critical / high / medium / low (based on urgency in description)
 
-### Drilling Down
-- View specific project details
-- See all tasks for a project
-- Check milestone progress
-- Review tag usage
+### 2. Project Recommendation (if no project specified)
+If user didn't specify a project, please:
+- List all active projects
+- Analyze which project the task content is most relevant to
+- Recommend the most suitable project
 
-### Taking Action
-- Identify projects needing attention
-- Find overdue tasks
-- Review completed work
-- Plan upcoming work
+### 3. Tag Suggestions
+Suggest relevant tags:
+- Type tags: bug, feature, refactor, docs
+- Priority tags: urgent, important
+- Domain tags: frontend, backend, design, testing (if applicable)
 
-## Example Queries
+### 4. Generate Task
+Use create_task to create the task
 
-**"Show me all active projects"**
-Lists projects with status = active, sorted by most recently updated
+### 5. Status Recommendation
+After creating the task, if you start working on it immediately, consider setting the status to in-progress. Use update_task to keep progress updated during work, and mark as done when completed.
 
-**"What tasks are overdue?"**
-Shows all tasks where due date < today and status != done
+## Example:
 
-**"Which projects are at risk?"**
-Identifies projects with overdue critical/high priority tasks
+**Input**: "User reported login page doesn't display correctly on mobile"
 
-**"Show my progress this week"**
-Displays tasks completed in the last 7 days
+**Output**:
+- Title: Fix login page mobile responsiveness issue
+- Description: User reported the login page displays abnormally on mobile devices, need to check responsive layout.
+- Type: Bug
+- Priority: High (affects user experience)
+- Suggested Tags: bug, frontend, mobile
+- Recommended Project: [Recommend if there's a web project]
 
-## Quick Actions
+## Current Idea Analysis:
 
-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
+Idea: "${idea}"
 
-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`
+Please analyze and generate task suggestions. After user confirmation, execute create_task to create the task.`
         }
       }
     ]
@@ -2061,14 +2042,14 @@ What would you like to do?
 }
 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);
+    case "recommendNextTasks":
+      return getRecommendNextTasksPrompt(args?.projectId, args?.limit);
+    case "autoPrioritize":
+      return getAutoPrioritizePrompt(args?.projectId);
+    case "enhanceTaskDetails":
+      return getEnhanceTaskDetailsPrompt(args?.taskId || "");
+    case "quickCapture":
+      return getQuickCapturePrompt(args?.idea || "", args?.projectId);
     default:
       return null;
   }
@@ -2103,7 +2084,7 @@ function createServer2() {
   const server = new Server(
     {
       name: "roadmap-skill",
-      version: "0.1.4"
+      version: "0.2.1"
     },
     {
       capabilities: {