internaltool-mcp 1.6.14 → 1.6.19

package/index.js

@@ -302,13 +302,17 @@ function registerTaskTools(server, { isAdmin, scopedProjectId }) {
 
   server.tool(
     'park_task',
-    `Pause a task and save your current work context so another developer can safely pick it up.
+    `Pause a task and hand it off safely so another developer can continue without losing any work.
 
-SAFETY REQUIREMENT: All local changes must be committed and pushed before parking.
-If there are uncommitted or unpushed changes, this tool will block and tell you to push first.
-This ensures no work is lost when someone else picks up the task.
+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 actually save.`,
+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'),
@@ -321,111 +325,209 @@ Set confirmed=false first to preview, then confirmed=true to actually save.`,
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       const task    = taskRes?.data?.task
 
-      // ── Safety check: block if there are uncommitted or unpushed changes ──
-      const cwd = repoPath || process.cwd()
+      const cwd      = repoPath || process.cwd()
       const repoRoot = findRepoRoot(cwd)
-      let gitBlockers = []
+
+      // ── Git safety checks ──────────────────────────────────────────────────
+      let uncommitted = false
+      let unpushedCount = 0
+      let currentBranch = ''
       if (repoRoot) {
         try {
           const porcelain = runGit('status --porcelain=v1', repoRoot)
-          const { localState } = parseGitStatus(porcelain)
-          if (localState === 'modified') {
-            gitBlockers.push('You have uncommitted local changes. Commit them first so your work is not lost:\n  git add . && git commit -m "<your message>" && git push')
-          }
+          uncommitted = parseGitStatus(porcelain).localState === 'modified'
         } catch { /* non-fatal */ }
         try {
-          const currentBranch = runGit('branch --show-current', repoRoot).trim()
+          currentBranch = runGit('branch --show-current', repoRoot).trim()
           if (currentBranch) {
-            runGit('fetch origin', repoRoot)
-            const unpushed = parseInt(runGit(`rev-list origin/${currentBranch}..HEAD --count`, repoRoot).trim(), 10) || 0
-            if (unpushed > 0) {
-              gitBlockers.push(`You have ${unpushed} unpushed commit(s) on "${currentBranch}". Push first so another developer can access them:\n  git push origin ${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 — treat as unpushed */ }
-      }
-
-      if (gitBlockers.length > 0) {
-        return text({
-          blocked: true,
-          reason: 'Cannot park task — changes are not fully committed and pushed.',
-          gitBlockers,
-          message: 'Fix the issues above, then call park_task again.',
-        })
+        } catch { /* remote branch may not exist */ }
       }
 
       if (!confirmed) {
         return text({
           preview: {
-            action:    'park_task',
-            taskId,
             task:      task ? { key: task.key, title: task.title, branch: task.github?.headBranch || null } : null,
-            willSave:  { summary: summary || '(empty)', remaining: remaining || '(empty)', blockers: blockers || '(empty)' },
-            cursorRulesNote: task?.cursorRules?.trim() ? `Cursor rules file (.cursor/rules/${task.key?.toLowerCase()}.mdc) will be removed while parked.` : null,
-            handoffNote: task?.github?.headBranch
-              ? `All work is pushed. Another developer can pick this up by running: git fetch origin && git checkout ${task.github.headBranch}`
-              : null,
+            parkNote:  { summary: summary || '(empty)', remaining: remaining || '(empty)', blockers: blockers || '(empty)' },
+            willAutomate: [
+              uncommitted ? `Auto-commit uncommitted changes with message: "wip(${task?.key?.toLowerCase()}): ${(summary || 'parking task').slice(0, 60)}"` : null,
+              unpushedCount > 0 || uncommitted ? `Push branch 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: 'All changes are pushed. Review the park note above then call park_task again with confirmed=true.',
+          message: 'Review the preview above, then call park_task again with confirmed=true to execute.',
         })
       }
 
-      const res = await api.patch(`/api/tasks/${taskId}/park`, { summary, remaining, blockers })
-      // Remove cursor rules file while task is parked — another task may be active
+      // ── Auto-commit if there are uncommitted changes ───────────────────────
+      if (repoRoot && uncommitted) {
+        try {
+          const commitMsg = `wip(${task?.key?.toLowerCase() || 'task'}): ${(summary || 'parking task').slice(0, 60)}`
+          runGit('add -A', repoRoot)
+          runGit(`commit -m "${commitMsg}"`, repoRoot)
+          unpushedCount += 1   // just committed, so now there's something to push
+        } catch (e) {
+          return text({ blocked: true, reason: `Auto-commit failed: ${e.message.split('\n')[0]}. Commit manually then call park_task again.` })
+        }
+      }
+
+      // ── 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({
-        ...(res?.data || {}),
-        cursorRulesCleared,
-        handoff: task?.github?.headBranch
-          ? { branch: task.github.headBranch, checkoutSteps: ['git fetch origin', `git checkout ${task.github.headBranch}`] }
-          : null,
+        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 — shows exactly what the previous developer left behind and what to do next.',
+    `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'),
-      repoPath:  z.string().optional().describe('Absolute path to the local git repo (defaults to MCP process working directory). Used to restore cursor rules file.'),
+      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, 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) {
         return text({
-          preview: {
-            action:    'unpark_task',
-            taskId,
-            task:      task ? { key: task.key, title: task.title, column: task.column } : null,
-            parkNote:  task?.parkNote || null,
+          HANDOFF_CONTEXT: {
+            task:         { key: task?.key, title: task?.title, priority: task?.priority },
+            parkNote:     task?.parkNote || null,
             branch,
-            handoffSteps: branch ? [
-              'git fetch origin',
-              `git checkout ${branch}`,
-              'git pull origin ' + branch + '  # get any commits the previous developer pushed',
-            ] : ['No branch linked yet — create one with create_branch'],
-            cursorRulesNote: task?.cursorRules?.trim() ? `Cursor rules will be restored to .cursor/rules/${task.key?.toLowerCase()}.mdc` : null,
-            willDo: 'Clear park note and mark task as active again',
+            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: 'Read the park note and handoff steps above, then call unpark_task again with confirmed=true to take ownership.',
+          message: 'Read the handoff context above. Call unpark_task again with confirmed=true to execute all steps automatically.',
         })
       }
-      const res = await api.patch(`/api/tasks/${taskId}/unpark`, {})
-      // Restore cursor rules file now that this task is active again
+
+      // ── 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)
+
+          // Auto-rebase from main so Dev B starts on a clean, up-to-date branch
+          let rebaseResult = null
+          try {
+            const behind = parseInt(runGit(`rev-list HEAD..origin/main --count`, repoRoot).trim(), 10) || 0
+            if (behind > 0) {
+              runGit('rebase origin/main', repoRoot)
+              runGit(`push origin ${branch} --force-with-lease`, repoRoot)
+              rebaseResult = { rebased: true, commitsBehind: behind, message: `Auto-rebased ${behind} commit(s) from main — branch is now up to date` }
+            } else {
+              rebaseResult = { rebased: false, message: 'Branch is already up to date with main' }
+            }
+          } catch (rebaseErr) {
+            rebaseResult = { rebased: false, conflict: true, message: 'Auto-rebase failed — merge conflict detected. Run: git rebase origin/main and resolve conflicts manually.' }
+          }
+
+          gitResult = { switched: true, branch, rebase: rebaseResult }
+        } catch (e) {
+          gitResult = { switched: false, error: e.message.split('\n')[0], manualSteps: [`git fetch origin`, `git checkout ${branch}`, `git pull origin ${branch}`, 'git rebase origin/main'] }
+        }
+      }
+
+      // ── 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({ ...(res?.data || {}), cursorRulesFile })
+
+      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.`,
+      })
     }
   )
 }
@@ -927,10 +1029,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
@@ -1729,7 +1839,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
@@ -2351,6 +2472,32 @@ branchAction values (only needed when current branch ≠ task branch):
         ...unsafeUntracked.map(f => `⚠️ SKIP:   ${f}  ← do not commit this`),
       ]
 
+      // ── Block if task is parked — prevent Dev A pushing after handoff ────────
+      if (task) {
+        const isParked      = !!(task.parkNote?.parkedAt)
+        const currentOwner  = task.parkNote?.currentOwner
+        const parkedBy      = task.parkNote?.parkedBy
+        let meId = ''
+        try { const me = await api.get('/api/auth/me'); meId = me?.data?.user?._id || me?.data?._id || '' } catch { /* non-fatal */ }
+
+        if (isParked && parkedBy && parkedBy.toString() === meId) {
+          return text({
+            blocked: true,
+            reason:  `You parked "${task.title}". Another developer may have picked it up.`,
+            advice:  'Check the task on the board before pushing. If you still own it, call unpark_task first, then commit.',
+            message: 'Commit blocked — task is parked.',
+          })
+        }
+        if (currentOwner && currentOwner.toString() !== meId && meId) {
+          return text({
+            blocked: true,
+            reason:  `"${task.title}" is currently owned by another developer who unparked it.`,
+            advice:  'Do not push to this branch. Coordinate with the current owner first.',
+            message: 'Commit blocked — another developer owns this task.',
+          })
+        }
+      }
+
       // ── PREVIEW (confirmed=false) ─────────────────────────────────────────────
       if (!confirmed) {
         // Case 1: branch mismatch — must resolve before anything else

package/package.json

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