internaltool-mcp 1.2.0 → 1.4.0

package/index.js

@@ -118,6 +118,20 @@ function registerUserTools(server) {
       return call(() => api.get(`/api/users/directory${qs}`))
     }
   )
+
+  server.tool(
+    'get_my_tasks',
+    'Get all tasks assigned to you. Optionally filter by column. Use this to find your active work before a hotfix or priority switch.',
+    {
+      column: z.enum(['backlog', 'todo', 'in_progress', 'in_review', 'done'])
+        .optional()
+        .describe('Filter to a specific column — e.g. "in_progress" to find your active task'),
+    },
+    async ({ column } = {}) => {
+      const qs = column ? `?column=${encodeURIComponent(column)}` : ''
+      return call(() => api.get(`/api/users/me/tasks${qs}`))
+    }
+  )
 }
 
 function registerProjectTools(server, { isAdmin, scopedProjectId }) {
@@ -269,12 +283,15 @@ function registerTaskTools(server, { isAdmin, scopedProjectId }) {
 
   server.tool(
     'park_task',
-    'Pause a task and save your current work context.',
+    `Pause a task and save your current work context.
+IMPORTANT: Before calling this, run "git diff HEAD" and "git status" in the terminal to see what has changed.
+Use that output to write precise summary/remaining/blockers fields — not generic text.
+This is the developer's saved mental state; make it detailed enough to resume cold tomorrow.`,
     {
       taskId:    z.string().describe("Task's MongoDB ObjectId"),
-      summary:   z.string().optional().describe('Work done so far'),
-      remaining: z.string().optional().describe('What still needs to be done'),
-      blockers:  z.string().optional().describe('What is blocking progress'),
+      summary:   z.string().optional().describe('What was built/changed — include file names and what was done'),
+      remaining: z.string().optional().describe('Specific next steps to complete this task'),
+      blockers:  z.string().optional().describe('Anything blocking progress'),
     },
     async ({ taskId, summary = '', remaining = '', blockers = '' }) =>
       call(() => api.patch(`/api/tasks/${taskId}/park`, { summary, remaining, blockers }))
@@ -288,6 +305,245 @@ function registerTaskTools(server, { isAdmin, scopedProjectId }) {
   )
 }
 
+function registerProductivityTools(server) {
+  server.tool(
+    'generate_standup',
+    `Generate a daily standup for the current user.
+Fetches all assigned tasks and their recent activity, then formats:
+- What was done yesterday (based on activity + park notes)
+- What is planned today (in_progress / todo tasks)
+- Any blockers
+
+Call this when the developer says "prepare my standup", "what did I do yesterday", or opens Cursor in the morning.`,
+    {},
+    async () => {
+      // Fetch all my tasks
+      const tasksRes = await api.get('/api/users/me/tasks')
+      if (!tasksRes?.success) return errorText('Could not fetch tasks')
+
+      const tasks = tasksRes.data.tasks
+      if (!tasks.length) return text({ standup: 'No assigned tasks found.', tasks: [] })
+
+      // Fetch activity for each task (parallel)
+      const withActivity = await Promise.all(
+        tasks.map(async (t) => {
+          try {
+            const actRes = await api.get(`/api/tasks/${t._id}/activity`)
+            return { ...t, activity: actRes?.data?.activity || [] }
+          } catch {
+            return { ...t, activity: [] }
+          }
+        })
+      )
+
+      // Summarise for standup
+      const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000)
+      const standup = withActivity.map((t) => {
+        const recentActivity = t.activity.filter(
+          (a) => new Date(a.createdAt) > yesterday
+        )
+        return {
+          taskId:      t._id,
+          key:         t.key,
+          title:       t.title,
+          column:      t.column,
+          priority:    t.priority,
+          project:     t.project?.name,
+          parkNote:    t.parkNote,
+          recentActivity: recentActivity.map((a) => a.message || a.type),
+        }
+      })
+
+      return text({ standup })
+    }
+  )
+
+  server.tool(
+    'end_of_day',
+    `End-of-day wrap-up. For every task currently in_progress:
+1. Parks it with the provided notes (run "git diff HEAD" first to fill these accurately)
+2. Returns a summary of what was wrapped
+
+After this tool runs, post a short comment on each parked task via add_task_comment summarising the day.
+Use this when the developer says "wrap up", "end of day", or "I'm done for today".`,
+    {
+      taskNotes: z.array(z.object({
+        taskId:    z.string().describe("Task's MongoDB ObjectId"),
+        summary:   z.string().describe('What was done today — be specific, include file names'),
+        remaining: z.string().describe('What is left to do next session'),
+        blockers:  z.string().optional().describe('Anything blocking'),
+      })).describe('Park notes for each in_progress task. Call get_my_tasks(column="in_progress") first to get the list.'),
+    },
+    async ({ taskNotes }) => {
+      const results = []
+      for (const note of taskNotes) {
+        try {
+          const res = await api.patch(`/api/tasks/${note.taskId}/park`, {
+            summary:   note.summary,
+            remaining: note.remaining,
+            blockers:  note.blockers || '',
+          })
+          results.push({
+            taskId:  note.taskId,
+            success: res?.success ?? false,
+            message: res?.success ? 'Parked' : (res?.message || 'Failed'),
+          })
+        } catch (e) {
+          results.push({ taskId: note.taskId, success: false, message: e.message })
+        }
+      }
+      return text({ wrapped: results })
+    }
+  )
+
+  server.tool(
+    'kickoff_task',
+    `Kick off a task — brief the developer and move it to in_progress.
+Fetches the full task details plus recent project commits for context.
+Returns everything needed to start: task plan, what recently changed in the repo, and the git branch command to run.
+Use this when a developer says "start task", "brief me on", or "what do I need to do for TASK-X".`,
+    {
+      taskId: z.string().describe("Task's MongoDB ObjectId"),
+    },
+    async ({ taskId }) => {
+      // Get full task
+      const taskRes = await api.get(`/api/tasks/${taskId}`)
+      if (!taskRes?.success) return errorText('Task not found')
+      const task = taskRes.data.task
+
+      // Get recent commits from the project
+      let recentCommits = []
+      try {
+        const commitsRes = await api.get(
+          `/api/projects/${task.project}/github/commits?per_page=10`
+        )
+        if (commitsRes?.success) recentCommits = commitsRes.data.commits || []
+      } catch { /* GitHub may not be linked */ }
+
+      // Move to in_progress
+      let moved = false
+      try {
+        const moveRes = await api.post(`/api/tasks/${taskId}/move`, {
+          column: 'in_progress',
+          toIndex: 0,
+        })
+        moved = moveRes?.success ?? false
+      } catch { /* might already be in_progress */ }
+
+      return text({
+        task: {
+          id:          task._id,
+          key:         task.key,
+          title:       task.title,
+          description: task.description,
+          priority:    task.priority,
+          column:      moved ? 'in_progress' : task.column,
+          readme:      task.readmeMarkdown,
+          subtasks:    task.subtasks,
+          parkNote:    task.parkNote,
+          approval:    task.approval,
+        },
+        recentCommits: recentCommits.slice(0, 5).map((c) => ({
+          sha:     c.sha?.slice(0, 7),
+          message: c.commit?.message?.split('\n')[0],
+          author:  c.commit?.author?.name,
+          date:    c.commit?.author?.date,
+        })),
+        movedToInProgress: moved,
+        suggestedBranch: `feature/${task.key?.toLowerCase()}-${task.title
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, '-')
+          .slice(0, 40)}`,
+      })
+    }
+  )
+
+  server.tool(
+    'check_stale_tasks',
+    `Find tasks assigned to you that have had no activity for N days.
+Use this to surface forgotten or blocked work.
+Call this when the developer asks "what have I been neglecting" or "any stale tasks".`,
+    {
+      staleDays: z.number().int().min(1).default(3).describe('Number of days without activity to consider stale'),
+    },
+    async ({ staleDays = 3 }) => {
+      const tasksRes = await api.get('/api/users/me/tasks')
+      if (!tasksRes?.success) return errorText('Could not fetch tasks')
+
+      const activeTasks = tasksRes.data.tasks.filter(
+        (t) => t.column === 'in_progress' || t.column === 'in_review'
+      )
+
+      const threshold = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000)
+
+      const stale = []
+      for (const task of activeTasks) {
+        try {
+          const actRes = await api.get(`/api/tasks/${task._id}/activity`)
+          const activity = actRes?.data?.activity || []
+          const lastActivity = activity.length
+            ? new Date(activity[activity.length - 1].createdAt)
+            : new Date(task.updatedAt || 0)
+
+          if (lastActivity < threshold) {
+            stale.push({
+              taskId:       task._id,
+              key:          task.key,
+              title:        task.title,
+              column:       task.column,
+              project:      task.project?.name,
+              daysSilent:   Math.floor((Date.now() - lastActivity) / (24 * 60 * 60 * 1000)),
+              lastActivity: lastActivity.toISOString(),
+              parkNote:     task.parkNote,
+            })
+          }
+        } catch { /* skip if activity fetch fails */ }
+      }
+
+      stale.sort((a, b) => b.daysSilent - a.daysSilent)
+      return text({ staleTasks: stale, checkedTasks: activeTasks.length })
+    }
+  )
+
+  server.tool(
+    'link_pr_to_task',
+    `Link a pull request to a task, post a comment, and move the task to in_review.
+Use this when a developer pushes a branch and opens a PR.
+Keeps the board in sync with git automatically.`,
+    {
+      taskId:    z.string().describe("Task's MongoDB ObjectId"),
+      prUrl:     z.string().describe('Full GitHub PR URL'),
+      prTitle:   z.string().optional().describe('PR title'),
+      branch:    z.string().optional().describe('Branch name'),
+    },
+    async ({ taskId, prUrl, prTitle, branch }) => {
+      const commentBody = [
+        `## Pull Request Opened`,
+        `**PR:** [${prTitle || prUrl}](${prUrl})`,
+        branch ? `**Branch:** \`${branch}\`` : '',
+        `**Status:** Ready for review`,
+      ].filter(Boolean).join('\n')
+
+      // Post comment
+      const commentRes = await api.post(`/api/tasks/${taskId}/comments`, {
+        body: commentBody,
+      })
+
+      // Move to in_review
+      const moveRes = await api.post(`/api/tasks/${taskId}/move`, {
+        column: 'in_review',
+        toIndex: 0,
+      })
+
+      return text({
+        commented:      commentRes?.success ?? false,
+        movedToReview:  moveRes?.success ?? false,
+        message:        'Task linked to PR and moved to in_review',
+      })
+    }
+  )
+}
+
 function registerIssueTools(server) {
   server.tool(
     'create_task_issue',
@@ -466,6 +722,7 @@ async function main() {
   registerUserTools(server)
   registerProjectTools(server, ctx)
   registerTaskTools(server, ctx)
+  registerProductivityTools(server)
   registerIssueTools(server)
   registerApprovalTools(server)
   registerCommentTools(server)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internaltool-mcp",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "MCP server for InternalTool — connect AI assistants (Claude Code, Cursor) to your project and task management platform",
   "type": "module",
   "main": "index.js",