internaltool-mcp 1.6.10 → 1.6.17

package/index.js

@@ -302,58 +302,213 @@ function registerTaskTools(server, { isAdmin, scopedProjectId }) {
 
   server.tool(
     'park_task',
-    `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.
+    `Pause a task and hand it off safely so another developer can continue without losing any work.
 
-Set confirmed=false first to preview, then confirmed=true to actually save.`,
+WHAT THIS DOES AUTOMATICALLY (confirmed=true):
+1. Verifies all changes are committed and pushed — blocks if not
+2. Auto-pushes any unpushed commits to remote
+3. Saves your park note (summary, remaining, blockers) to the task
+4. Deletes the cursor rules file (.cursor/rules/<task>.mdc) so it doesn't bleed into other tasks
+5. Posts a comment on the task with your handoff notes (visible to Dev B)
+6. Notifies all project members that this task is parked and ready for pickup
+
+Set confirmed=false first to preview, then confirmed=true to execute everything.`,
     {
       taskId:    z.string().describe("Task's MongoDB ObjectId"),
       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'),
       confirmed: z.boolean().optional().default(false).describe('Set true to execute after reviewing the preview'),
+      repoPath:  z.string().optional().describe('Absolute path to the local git repo (defaults to MCP process working directory).'),
     },
-    async ({ taskId, summary = '', remaining = '', blockers = '', confirmed = false }) => {
+    async ({ taskId, summary = '', remaining = '', blockers = '', confirmed = false, repoPath }) => {
+      const taskRes = await api.get(`/api/tasks/${taskId}`)
+      const task    = taskRes?.data?.task
+
+      const cwd      = repoPath || process.cwd()
+      const repoRoot = findRepoRoot(cwd)
+
+      // ── Git safety checks ──────────────────────────────────────────────────
+      let uncommitted = false
+      let unpushedCount = 0
+      let currentBranch = ''
+      if (repoRoot) {
+        try {
+          const porcelain = runGit('status --porcelain=v1', repoRoot)
+          uncommitted = parseGitStatus(porcelain).localState === 'modified'
+        } catch { /* non-fatal */ }
+        try {
+          currentBranch = runGit('branch --show-current', repoRoot).trim()
+          if (currentBranch) {
+            try { runGit('fetch origin', repoRoot) } catch { /* no network */ }
+            unpushedCount = parseInt(runGit(`rev-list origin/${currentBranch}..HEAD --count`, repoRoot).trim(), 10) || 0
+          }
+        } catch { /* remote branch may not exist */ }
+      }
+
+      if (uncommitted) {
+        return text({
+          blocked: true,
+          reason:  'You have uncommitted local changes.',
+          fix:     'Commit your changes first, then call park_task again.',
+          commands: ['git add .', 'git commit -m "wip: parking task — <describe what you did>"'],
+          message: 'Cannot park until all changes are committed.',
+        })
+      }
+
       if (!confirmed) {
         return text({
           preview: {
-            action:    'park_task',
-            taskId,
-            willSave:  { summary: summary || '(empty)', remaining: remaining || '(empty)', blockers: blockers || '(empty)' },
+            task:      task ? { key: task.key, title: task.title, branch: task.github?.headBranch || null } : null,
+            parkNote:  { summary: summary || '(empty)', remaining: remaining || '(empty)', blockers: blockers || '(empty)' },
+            willAutomate: [
+              unpushedCount > 0 ? `Push ${unpushedCount} unpushed commit(s) to remote` : 'Branch is already up to date on remote',
+              'Save park note to task',
+              task?.cursorRules?.trim() ? 'Delete cursor rules file (.cursor/rules/' + task.key?.toLowerCase() + '.mdc)' : null,
+              'Post handoff comment on the task',
+              'Notify project members',
+            ].filter(Boolean),
           },
           requiresConfirmation: true,
-          message: 'Review the park note above. Call park_task again with confirmed=true to save it.',
+          message: 'Review the preview above, then call park_task again with confirmed=true to execute.',
         })
       }
-      return call(() => api.patch(`/api/tasks/${taskId}/park`, { summary, remaining, blockers }))
+
+      // ── Auto-push unpushed commits ─────────────────────────────────────────
+      let pushed = false
+      if (repoRoot && currentBranch && unpushedCount > 0) {
+        try {
+          runGit(`push origin ${currentBranch}`, repoRoot)
+          pushed = true
+        } catch (e) {
+          return text({ blocked: true, reason: `Auto-push failed: ${e.message.split('\n')[0]}. Push manually then call park_task again.` })
+        }
+      }
+
+      // ── Save park note + server-side comment & notifications ──────────────
+      await api.patch(`/api/tasks/${taskId}/park`, { summary, remaining, blockers })
+
+      // ── Delete cursor rules file ───────────────────────────────────────────
+      let cursorRulesCleared = null
+      if (task?.cursorRules?.trim()) {
+        cursorRulesCleared = deleteCursorRulesFile(task.key, repoPath)
+      }
+
+      return text({
+        parked: true,
+        task:   { key: task?.key, title: task?.title, branch: task?.github?.headBranch || null },
+        autoPushed: pushed ? `${unpushedCount} commit(s) pushed to origin/${currentBranch}` : 'No push needed',
+        cursorRulesCleared: cursorRulesCleared ? `Deleted ${cursorRulesCleared}` : null,
+        commentPosted: true,
+        teamNotified:  true,
+        message: 'Task parked. Project members have been notified. Dev B can run unpark_task to continue.',
+      })
     }
   )
 
   server.tool(
     'unpark_task',
-    'Resume a parked task. Set confirmed=false first to preview, then confirmed=true to execute.',
+    `Pick up a parked task and get fully set up to continue the previous developer's work.
+
+WHAT THIS DOES AUTOMATICALLY (confirmed=true):
+1. Shows the full park note from the previous developer before doing anything
+2. Shows the last 5 commits on the branch so you know the exact state of the code
+3. Shows recent task comments so you have full context
+4. Runs: git fetch origin + git checkout <branch> + git pull (switches your local repo)
+5. Restores the cursor rules file (.cursor/rules/<task>.mdc) so Cursor follows task rules
+6. Posts a comment that you picked up the task
+7. Notifies the previous developer that you have taken over
+
+Set confirmed=false first to read everything, then confirmed=true to execute.`,
     {
       taskId:    z.string().describe("Task's MongoDB ObjectId"),
-      confirmed: z.boolean().optional().default(false).describe('Set true to execute after reviewing the preview'),
+      confirmed: z.boolean().optional().default(false).describe('Set true to execute after reviewing the park note'),
+      repoPath:  z.string().optional().describe('Absolute path to the local git repo (defaults to MCP process working directory).'),
     },
-    async ({ taskId, confirmed = false }) => {
+    async ({ taskId, confirmed = false, repoPath }) => {
+      const taskRes = await api.get(`/api/tasks/${taskId}`)
+      const task    = taskRes?.data?.task
+      const branch  = task?.github?.headBranch || null
+
+      // ── Fetch recent commits on the branch ────────────────────────────────
+      let recentCommits = []
+      if (branch) {
+        try {
+          const commitsRes = await api.get(`/api/projects/${task.project}/github/commits?per_page=5&branch=${branch}`)
+          recentCommits = commitsRes?.data?.commits || []
+        } catch { /* non-fatal */ }
+      }
+
+      // ── Fetch recent task comments ─────────────────────────────────────────
+      let recentComments = []
+      try {
+        const commentsRes = await api.get(`/api/tasks/${taskId}/comments`)
+        recentComments = (commentsRes?.data?.comments || []).slice(-5).map(c => ({
+          author: c.author?.name || c.author?.email || 'unknown',
+          body:   c.body?.slice(0, 300),
+          at:     c.createdAt,
+        }))
+      } catch { /* non-fatal */ }
+
       if (!confirmed) {
-        const taskRes = await api.get(`/api/tasks/${taskId}`)
-        const task    = taskRes?.data?.task
         return text({
-          preview: {
-            action:    'unpark_task',
-            taskId,
-            task:      task ? { key: task.key, title: task.title, parkNote: task.parkNote } : null,
-            willDo:    'Clear park note and mark task as active again',
+          HANDOFF_CONTEXT: {
+            task:         { key: task?.key, title: task?.title, priority: task?.priority },
+            parkNote:     task?.parkNote || null,
+            branch,
+            recentCommits: recentCommits.length ? recentCommits.map(c => `${c.sha?.slice(0,7)} ${c.commit?.message?.split('\n')[0]} — ${c.commit?.author?.name}`) : ['No commits found'],
+            recentComments,
           },
+          willAutomate: branch ? [
+            `git fetch origin`,
+            `git checkout ${branch}`,
+            `git pull origin ${branch}`,
+            task?.cursorRules?.trim() ? `Restore .cursor/rules/${task.key?.toLowerCase()}.mdc` : null,
+            'Post "picked up" comment on task',
+            'Notify previous developer',
+          ].filter(Boolean) : ['No branch linked — create one with create_branch after unparking'],
           requiresConfirmation: true,
-          message: 'Call unpark_task again with confirmed=true to resume this task.',
+          message: 'Read the handoff context above. Call unpark_task again with confirmed=true to execute all steps automatically.',
         })
       }
-      return call(() => api.patch(`/api/tasks/${taskId}/unpark`, {}))
+
+      // ── Auto-execute git branch switch ────────────────────────────────────
+      const cwd      = repoPath || process.cwd()
+      const repoRoot = findRepoRoot(cwd)
+      let gitResult  = null
+
+      if (repoRoot && branch) {
+        try {
+          runGit('fetch origin', repoRoot)
+          runGit(`checkout ${branch}`, repoRoot)
+          runGit(`pull origin ${branch}`, repoRoot)
+          gitResult = { switched: true, branch }
+        } catch (e) {
+          gitResult = { switched: false, error: e.message.split('\n')[0], manualSteps: [`git fetch origin`, `git checkout ${branch}`, `git pull origin ${branch}`] }
+        }
+      }
+
+      // ── Clear park note + server-side comment & notification ──────────────
+      await api.patch(`/api/tasks/${taskId}/unpark`, {})
+
+      // ── Restore cursor rules file ──────────────────────────────────────────
+      let cursorRulesFile = null
+      if (task?.cursorRules?.trim()) {
+        cursorRulesFile = writeCursorRulesFile(task.key, task.cursorRules, repoPath)
+      }
+
+      return text({
+        unparked: true,
+        task:     { key: task?.key, title: task?.title },
+        git:      gitResult || { switched: false, reason: 'No branch linked or repo not found' },
+        cursorRules: cursorRulesFile ? { restored: true, path: cursorRulesFile } : { restored: false },
+        commentPosted:       true,
+        previousDevNotified: true,
+        parkNote: task?.parkNote || null,
+        message: gitResult?.switched
+          ? `You are now on branch "${branch}". Cursor rules restored. Start coding from where ${task?.parkNote?.parkedBy ? 'the previous developer' : 'you'} left off.`
+          : `Branch switch failed — see git.manualSteps. Cursor rules restored.`,
+      })
     }
   )
 }
@@ -855,10 +1010,18 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
       if (!taskRes?.success) return errorText('Task not found')
       const task = taskRes.data.task
 
-      const suggestedBranch = `feature/${task.key?.toLowerCase()}-${task.title
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .slice(0, 40)}`
+      // Include developer name in branch so it's clear who created it
+      let devSlug = ''
+      try {
+        const meRes = await api.get('/api/auth/me')
+        const devName = meRes?.data?.user?.name || meRes?.data?.name || ''
+        devSlug = devName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 15)
+      } catch { /* non-fatal */ }
+
+      const titleSlug = task.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 35)
+      const suggestedBranch = devSlug
+        ? `${devSlug}/feature/${task.key?.toLowerCase()}-${titleSlug}`
+        : `feature/${task.key?.toLowerCase()}-${titleSlug}`
 
       const hasReadme     = typeof task.readmeMarkdown === 'string' && task.readmeMarkdown.trim().length > 0
       const hasCursorRules = typeof task.cursorRules === 'string' && task.cursorRules.trim().length > 0
@@ -904,6 +1067,39 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
         ]
       }
 
+      // ── Simultaneous work lock ──────────────────────────────────────────────────
+      // If the task is already in_progress with a branch, warn before proceeding.
+      // This prevents two developers from unknowingly working on the same task.
+      const alreadyActive = task.column === 'in_progress' && !!task.github?.headBranch
+      const activeAssignees = (task.assignees || []).map(a => a.name || a.email || a.toString())
+
+      if (!confirmed && alreadyActive) {
+        return text({
+          warning: {
+            type:       'simultaneous_work_detected',
+            message:    `⚠️ This task is already in progress on branch "${task.github.headBranch}".`,
+            assignees:  activeAssignees.length ? activeAssignees : ['(unassigned)'],
+            branch:     task.github.headBranch,
+            parkNote:   task.parkNote || null,
+            advice:     activeAssignees.length
+              ? `Check with ${activeAssignees.join(', ')} before taking over. If they have parked this task their changes are pushed — checkout their branch instead of starting fresh.`
+              : `Someone may have been working on this. Check the branch before starting fresh.`,
+            checkoutSteps: [
+              'git fetch origin',
+              `git checkout ${task.github.headBranch}`,
+              `git pull origin ${task.github.headBranch}`,
+            ],
+          },
+          brief: {
+            key:         task.key,
+            title:       task.title,
+            priority:    task.priority,
+          },
+          requiresConfirmation: true,
+          message: `Task is already in progress. Read the warning above. If you still want to take over, call kickoff_task again with confirmed=true.`,
+        })
+      }
+
       if (!confirmed) {
         return text({
           CURSOR_RULES: hasCursorRules
@@ -1308,6 +1504,32 @@ function parseGitStatus(porcelain) {
   return { staged, unstaged, untracked, modified, localState }
 }
 
+/**
+ * Returns how many commits the current branch is behind/ahead of its base branch,
+ * and whether there are uncommitted changes. Fetches from origin first.
+ * Returns null on any git error (e.g. no remote configured).
+ */
+function getBranchSyncStatus(cwd, baseBranch = 'main') {
+  try {
+    runGit('fetch origin', cwd)
+  } catch { /* no remote or no network — continue with local data */ }
+  try {
+    const behind    = parseInt(runGit(`rev-list HEAD..origin/${baseBranch} --count`, cwd).trim(), 10) || 0
+    const unpushed  = parseInt(runGit(`rev-list origin/${baseBranch}..HEAD --count`, cwd).trim(), 10) || 0
+    // Check if the remote tracking branch for the feature branch exists and has unpushed commits
+    let unpushedOnBranch = 0
+    try {
+      const currentBranch = runGit('branch --show-current', cwd).trim()
+      unpushedOnBranch = parseInt(runGit(`rev-list origin/${currentBranch}..HEAD --count`, cwd).trim(), 10) || 0
+    } catch { /* remote branch may not exist yet — all commits are unpushed */ }
+    const porcelain = runGit('status --porcelain=v1', cwd)
+    const { localState } = parseGitStatus(porcelain)
+    return { behind, unpushed, unpushedOnBranch, localState, baseBranch }
+  } catch {
+    return null
+  }
+}
+
 // ── Git Workflow Tools ─────────────────────────────────────────────────────────
 // All write operations require confirmed=true after showing a preview.
 // This gives developers full visibility before anything is executed.
@@ -1598,7 +1820,18 @@ If you have uncommitted tracked changes, it will tell you exactly what to do bef
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-|-$/g, '')
         .slice(0, 35)
-      const branchName = `${prefix}/${task.key.toLowerCase()}-${slug}`
+
+      // Include developer name so it's clear who created the branch
+      let devSlug = ''
+      try {
+        const meRes = await api.get('/api/auth/me')
+        const devName = meRes?.data?.user?.name || meRes?.data?.name || ''
+        devSlug = devName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 15)
+      } catch { /* non-fatal */ }
+
+      const branchName = devSlug
+        ? `${devSlug}/${prefix}/${task.key.toLowerCase()}-${slug}`
+        : `${prefix}/${task.key.toLowerCase()}-${slug}`
 
       // Auto-detect local git state
       let gitState = null
@@ -2028,8 +2261,33 @@ Set confirmed=false first to preview the full PR content, then confirmed=true to
       ].filter(v => v !== null).join('\n')
 
       if (!confirmed) {
+        // ── Pre-flight: check branch sync status before allowing PR ──
+        const cwd = repoPath || process.cwd()
+        const repoRoot = findRepoRoot(cwd)
+        const sync = repoRoot ? getBranchSyncStatus(repoRoot) : null
+
+        const preflight = { status: 'ok', warnings: [], blockers: [] }
+        if (sync) {
+          if (sync.behind > 0) {
+            preflight.blockers.push(
+              `Branch is ${sync.behind} commit(s) behind origin/${sync.baseBranch}. Rebase before raising PR to avoid merge conflicts: git fetch origin && git rebase origin/${sync.baseBranch}`
+            )
+          }
+          if (sync.unpushedOnBranch > 0) {
+            preflight.blockers.push(
+              `You have ${sync.unpushedOnBranch} local commit(s) not pushed to remote. Push first: git push origin ${headBranch}`
+            )
+          }
+          if (sync.localState === 'modified') {
+            preflight.warnings.push('You have uncommitted local changes. Commit or stash them before the PR is merged.')
+          }
+          if (preflight.blockers.length > 0) preflight.status = 'blocked'
+          else if (preflight.warnings.length > 0) preflight.status = 'warning'
+        }
+
         return text({
-          preview: {
+          preflight,
+          preview: preflight.status === 'blocked' ? null : {
             action:     'raise_pr',
             prTitle,
             prBody:     bodyParts,
@@ -2037,8 +2295,10 @@ Set confirmed=false first to preview the full PR content, then confirmed=true to
             draft,
             task:       { key: task.key, title: task.title },
           },
-          requiresConfirmation: true,
-          message: `Will open a${draft ? ' draft' : ''} PR titled "${prTitle}". Call raise_pr again with confirmed=true to create it.`,
+          requiresConfirmation: preflight.status !== 'blocked',
+          message: preflight.status === 'blocked'
+            ? `⛔ Cannot raise PR — fix the blockers above first.`
+            : `Will open a${draft ? ' draft' : ''} PR titled "${prTitle}". Call raise_pr again with confirmed=true to create it.`,
         })
       }
 
@@ -2246,6 +2506,20 @@ branchAction values (only needed when current branch ≠ task branch):
 
         // Case 2: on correct branch — standard preview
         const pushCmd = `git push origin ${currentBranch}`
+
+        // Check if branch is behind base — warn developer to rebase before more commits pile up
+        let divergenceWarning = null
+        try {
+          runGit('fetch origin', cwd)
+          const repoRoot = findRepoRoot(cwd)
+          if (repoRoot) {
+            const behind = parseInt(runGit(`rev-list HEAD..origin/main --count`, repoRoot).trim(), 10) || 0
+            if (behind > 0) {
+              divergenceWarning = `⚠️ Your branch is ${behind} commit(s) behind origin/main. Rebase now to prevent merge conflicts later:\n  git fetch origin && git rebase origin/main\nThen re-run your commits.`
+            }
+          }
+        } catch { /* non-fatal */ }
+
         return text({
           preview: {
             suggestedMessage: commitMsg,
@@ -2256,6 +2530,7 @@ branchAction values (only needed when current branch ≠ task branch):
             onCorrectBranch:  !branchMismatch,
             changedFiles:     changedFilesList,
           },
+          divergenceWarning,
           unsafeUntrackedWarning: unsafeUntracked.length
             ? `These paths should NOT be committed — add them to .gitignore first: ${unsafeUntracked.join(', ')}`
             : null,

package/package.json

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