internaltool-mcp 1.6.9 → 1.6.14

package/index.js

@@ -18,7 +18,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { execSync } from 'child_process'
-import { mkdirSync, writeFileSync, unlinkSync, existsSync } from 'fs'
+import { mkdirSync, writeFileSync, unlinkSync, existsSync, readdirSync, statSync } from 'fs'
 import { join } from 'path'
 import { z } from 'zod'
 import { api, login, configure } from './api-client.js'
@@ -302,10 +302,11 @@ 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 save your current work context so another developer can safely pick it up.
+
+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.
 
 Set confirmed=false first to preview, then confirmed=true to actually save.`,
     {
@@ -314,46 +315,117 @@ Set confirmed=false first to preview, then confirmed=true to actually save.`,
       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
+
+      // ── Safety check: block if there are uncommitted or unpushed changes ──
+      const cwd = repoPath || process.cwd()
+      const repoRoot = findRepoRoot(cwd)
+      let gitBlockers = []
+      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')
+          }
+        } catch { /* non-fatal */ }
+        try {
+          const 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}`)
+            }
+          }
+        } 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.',
+        })
+      }
+
       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,
           },
           requiresConfirmation: true,
-          message: 'Review the park note above. Call park_task again with confirmed=true to save it.',
+          message: 'All changes are pushed. Review the park note above then call park_task again with confirmed=true.',
         })
       }
-      return call(() => api.patch(`/api/tasks/${taskId}/park`, { summary, remaining, blockers }))
+
+      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
+      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,
+      })
     }
   )
 
   server.tool(
     'unpark_task',
-    'Resume a parked task. Set confirmed=false first to preview, then confirmed=true to execute.',
+    'Resume a parked task — shows exactly what the previous developer left behind and what to do next.',
     {
       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.'),
     },
-    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
       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',
+            task:      task ? { key: task.key, title: task.title, column: task.column } : null,
+            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',
           },
           requiresConfirmation: true,
-          message: 'Call unpark_task again with confirmed=true to resume this task.',
+          message: 'Read the park note and handoff steps above, then call unpark_task again with confirmed=true to take ownership.',
         })
       }
-      return call(() => api.patch(`/api/tasks/${taskId}/unpark`, {}))
+      const res = await api.patch(`/api/tasks/${taskId}/unpark`, {})
+      // Restore cursor rules file now that this task is active again
+      let cursorRulesFile = null
+      if (task?.cursorRules?.trim()) {
+        cursorRulesFile = writeCursorRulesFile(task.key, task.cursorRules, repoPath)
+      }
+      return text({ ...(res?.data || {}), cursorRulesFile })
     }
   )
 }
@@ -848,8 +920,9 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
     {
       taskId:    z.string().describe("Task's MongoDB ObjectId"),
       confirmed: z.boolean().optional().default(false).describe('Set true after reading the plan to move the task to in_progress'),
+      repoPath:  z.string().optional().describe('Absolute path to the local git repo (defaults to MCP process working directory). Used to write cursor rules file.'),
     },
-    async ({ taskId, confirmed = false }) => {
+    async ({ taskId, confirmed = false, repoPath }) => {
       const taskRes = await api.get(`/api/tasks/${taskId}`)
       if (!taskRes?.success) return errorText('Task not found')
       const task = taskRes.data.task
@@ -903,6 +976,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
@@ -963,7 +1069,7 @@ Use this when a developer says "start task", "brief me on", or "what do I need t
       // Write cursor rules file to local repo immediately on kickoff
       let cursorRulesFile = null
       if (hasCursorRules) {
-        cursorRulesFile = writeCursorRulesFile(task.key, task.cursorRules)
+        cursorRulesFile = writeCursorRulesFile(task.key, task.cursorRules, repoPath)
       }
 
       return text({
@@ -1238,10 +1344,33 @@ function runGit(args, cwd) {
   }).trim()
 }
 
+/**
+ * Find the root of the git repo starting from `startPath`.
+ * If `startPath` itself is not a git repo, scan one level of subdirectories.
+ * Returns the repo root string or null.
+ */
+function findRepoRoot(startPath) {
+  const base = startPath || process.cwd()
+  try {
+    return runGit('rev-parse --show-toplevel', base)
+  } catch { /* not a git repo — try subdirectories */ }
+  try {
+    const entries = readdirSync(base, { withFileTypes: true })
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      try {
+        return runGit('rev-parse --show-toplevel', join(base, entry.name))
+      } catch { /* not a git repo */ }
+    }
+  } catch { /* can't read dir */ }
+  return null
+}
+
 /** Write task-specific cursor rules to .cursor/rules/<taskKey>.mdc in the local repo root. */
-function writeCursorRulesFile(taskKey, rulesMarkdown) {
+function writeCursorRulesFile(taskKey, rulesMarkdown, startPath) {
   try {
-    const repoRoot = runGit('rev-parse --show-toplevel', process.cwd())
+    const repoRoot = findRepoRoot(startPath)
+    if (!repoRoot) return null
     const rulesDir = join(repoRoot, '.cursor', 'rules')
     mkdirSync(rulesDir, { recursive: true })
     const filePath = join(rulesDir, `${taskKey.toLowerCase()}.mdc`)
@@ -1254,9 +1383,10 @@ function writeCursorRulesFile(taskKey, rulesMarkdown) {
 }
 
 /** Delete the task-specific cursor rules file when work is complete. */
-function deleteCursorRulesFile(taskKey) {
+function deleteCursorRulesFile(taskKey, startPath) {
   try {
-    const repoRoot = runGit('rev-parse --show-toplevel', process.cwd())
+    const repoRoot = findRepoRoot(startPath)
+    if (!repoRoot) return null
     const filePath = join(repoRoot, '.cursor', 'rules', `${taskKey.toLowerCase()}.mdc`)
     if (existsSync(filePath)) {
       unlinkSync(filePath)
@@ -1283,6 +1413,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.
@@ -1690,7 +1846,7 @@ If you have uncommitted tracked changes, it will tell you exactly what to do bef
         const freshTaskForRules = await api.get(`/api/tasks/${taskId}`).catch(() => null)
         const cursorRulesContent = freshTaskForRules?.data?.task?.cursorRules
         if (cursorRulesContent?.trim()) {
-          cursorRulesFile = writeCursorRulesFile(freshTaskForRules.data.task.key, cursorRulesContent)
+          cursorRulesFile = writeCursorRulesFile(freshTaskForRules.data.task.key, cursorRulesContent, cwd)
         }
 
         const checkoutSteps = [
@@ -1977,8 +2133,9 @@ Set confirmed=false first to preview the full PR content, then confirmed=true to
       additionalNotes: z.string().optional().describe('Extra context to add to the PR body'),
       draft:           z.boolean().optional().default(false).describe('Open as a draft PR (not yet ready for review)'),
       confirmed:       z.boolean().optional().default(false).describe('Set true to create the PR after reviewing the preview'),
+      repoPath:        z.string().optional().describe('Absolute path to the local git repo (defaults to MCP process working directory). Used to delete cursor rules file.'),
     },
-    async ({ taskId, projectId, headBranch, additionalNotes = '', draft = false, confirmed = false }) => {
+    async ({ taskId, projectId, headBranch, additionalNotes = '', draft = false, confirmed = false, repoPath }) => {
       if (scopedProjectId && projectId !== scopedProjectId) {
         return errorText(`Access denied: session is scoped to project ${scopedProjectId}`)
       }
@@ -2002,8 +2159,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,
@@ -2011,8 +2193,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.`,
         })
       }
 
@@ -2026,7 +2210,7 @@ Set confirmed=false first to preview the full PR content, then confirmed=true to
         if (!res?.success) return errorText(res?.message || 'Could not create PR')
 
         // Delete the task-specific cursor rules file — coding is done
-        const deletedRulesFile = deleteCursorRulesFile(task.key)
+        const deletedRulesFile = deleteCursorRulesFile(task.key, repoPath)
 
         return text({
           prNumber: res.data.prNumber,
@@ -2220,6 +2404,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,
@@ -2230,6 +2428,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.9",
+  "version": "1.6.14",
   "description": "MCP server for InternalTool — connect AI assistants (Claude Code, Cursor) to your project and task management platform",
   "type": "module",
   "main": "index.js",