@programinglive/dev-workflow-mcp-server 1.0.4 → 1.0.8

package/index.js

@@ -27,6 +27,8 @@ export class WorkflowState {
       bugFixed: false,
       testsCreated: false,
       testsPassed: false,
+      testsSkipped: false,
+      testsSkippedReason: "",
       documentationCreated: false,
       readyToCommit: false,
       readyCheckCompleted: false,
@@ -51,6 +53,12 @@ export class WorkflowState {
       if (typeof this.state.testsCreated !== "boolean") {
         this.state.testsCreated = false;
       }
+      if (typeof this.state.testsSkipped !== "boolean") {
+        this.state.testsSkipped = false;
+      }
+      if (typeof this.state.testsSkippedReason !== "string") {
+        this.state.testsSkippedReason = "";
+      }
       if (typeof this.state.readyCheckCompleted !== "boolean") {
         this.state.readyCheckCompleted = false;
       }
@@ -88,6 +96,8 @@ export class WorkflowState {
       bugFixed: false,
       testsCreated: false,
       testsPassed: false,
+      testsSkipped: false,
+      testsSkippedReason: "",
       documentationCreated: false,
       readyToCommit: false,
       readyCheckCompleted: false,
@@ -186,6 +196,279 @@ async function hasWorkingChanges() {
   }
 }
 
+export function workingTreeSummary(statusOutput) {
+  if (typeof statusOutput !== "string" || statusOutput.trim() === "") {
+    return {
+      hasChanges: false,
+      lines: [],
+    };
+  }
+
+  const lines = statusOutput
+    .split("\n")
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter(Boolean);
+
+  return {
+    hasChanges: lines.length > 0,
+    lines,
+  };
+}
+
+function isTestFilePath(filePath) {
+  if (!filePath) {
+    return false;
+  }
+
+  if (/\.(test|spec)\.[^.]+$/i.test(filePath)) {
+    return true;
+  }
+
+  return /(\/|^)(__tests__|tests?|spec)\//i.test(filePath);
+}
+
+function extractPathFromStatusLine(line) {
+  if (!line || line.length < 4) {
+    return "";
+  }
+
+  const rawPath = line.slice(3).trim();
+  if (!rawPath) {
+    return "";
+  }
+
+  if (rawPath.includes(" -> ")) {
+    const parts = rawPath.split(" -> ");
+    return parts[parts.length - 1].trim();
+  }
+
+  return rawPath;
+}
+
+export function containsTestFilesInStatus(statusOutput) {
+  if (typeof statusOutput !== "string" || statusOutput.trim() === "") {
+    return false;
+  }
+
+  return statusOutput
+    .split("\n")
+    .map((line) => extractPathFromStatusLine(line))
+    .some((path) => isTestFilePath(path));
+}
+
+function isDocumentationFilePath(filePath) {
+  if (!filePath) {
+    return false;
+  }
+
+  const normalized = filePath.toLowerCase();
+  return (
+    normalized.startsWith("docs/") ||
+    normalized.startsWith("documentation/") ||
+    normalized.endsWith(".md") ||
+    normalized.endsWith(".rst") ||
+    normalized.endsWith(".adoc") ||
+    normalized.includes("readme")
+  );
+}
+
+function parseNameStatusLine(line) {
+  if (!line) {
+    return null;
+  }
+
+  const parts = line.split("\t").map((part) => part.trim());
+  const status = parts[0];
+  if (!status) {
+    return null;
+  }
+
+  if (status.startsWith("R") || status.startsWith("C")) {
+    const originalPath = parts[1] || "";
+    const newPath = parts[2] || originalPath;
+    return {
+      status,
+      path: newPath,
+      originalPath,
+    };
+  }
+
+  return {
+    status,
+    path: parts[1] || "",
+    originalPath: "",
+  };
+}
+
+function formatFileList(paths) {
+  const uniquePaths = [...new Set(paths.filter(Boolean))];
+
+  if (uniquePaths.length === 0) {
+    return "updates";
+  }
+
+  if (uniquePaths.length === 1) {
+    return uniquePaths[0];
+  }
+
+  if (uniquePaths.length === 2) {
+    return `${uniquePaths[0]} and ${uniquePaths[1]}`;
+  }
+
+  if (uniquePaths.length === 3) {
+    return `${uniquePaths[0]}, ${uniquePaths[1]}, and ${uniquePaths[2]}`;
+  }
+
+  const remaining = uniquePaths.length - 3;
+  return `${uniquePaths[0]}, ${uniquePaths[1]}, ${uniquePaths[2]} +${remaining} more`;
+}
+
+function determineCommitType(changes) {
+  const hasTestChange = changes.some((change) =>
+    [change.path, change.originalPath].some((p) => isTestFilePath(p))
+  );
+  const hasDocsChange = changes.some((change) =>
+    [change.path, change.originalPath].some((p) => isDocumentationFilePath(p))
+  );
+
+  if (hasTestChange) {
+    return "test";
+  }
+
+  if (hasDocsChange) {
+    return "docs";
+  }
+
+  return "chore";
+}
+
+function describeChange(change) {
+  const statusCode = change.status || "";
+  const path = change.path || change.originalPath || "";
+
+  if (statusCode.startsWith("R")) {
+    return `renamed ${change.originalPath} -> ${change.path}`;
+  }
+
+  if (statusCode.startsWith("C")) {
+    return `copied ${change.originalPath} -> ${change.path}`;
+  }
+
+  switch (statusCode[0]) {
+    case "A":
+      return `added ${path}`;
+    case "M":
+      return `modified ${path}`;
+    case "D":
+      return `removed ${path}`;
+    case "U":
+      return `updated ${path}`;
+    default:
+      return `${statusCode} ${path}`.trim();
+  }
+}
+
+export function createCommitMessageParts(changes, providedSummary = "") {
+  const summaryInput = typeof providedSummary === "string" ? providedSummary.trim() : "";
+
+  if (!Array.isArray(changes) || changes.length === 0) {
+    return {
+      summary: summaryInput,
+      body: "",
+    };
+  }
+
+  const commitType = determineCommitType(changes);
+  const summaryPaths = changes
+    .map((change) => change.path || change.originalPath)
+    .filter(Boolean);
+  const generatedSummary = `${commitType}: update ${formatFileList(summaryPaths)}`;
+  const summary = summaryInput || generatedSummary;
+
+  const detailLines = changes
+    .map((change) => describeChange(change))
+    .filter((line) => line && line.trim().length > 0)
+    .map((line) => `- ${line}`);
+
+  return {
+    summary,
+    body: detailLines.join("\n"),
+  };
+}
+
+async function getStagedChanges() {
+  try {
+    const { stdout } = await exec("git diff --cached --name-status");
+    return stdout
+      .split("\n")
+      .map((line) => parseNameStatusLine(line))
+      .filter(Boolean);
+  } catch (error) {
+    return [];
+  }
+}
+
+async function hasTestChanges() {
+  try {
+    const { stdout } = await exec("git status --porcelain");
+    return containsTestFilesInStatus(stdout);
+  } catch (error) {
+    return false;
+  }
+}
+
+function normalizeCommitHeader(message) {
+  if (typeof message !== "string") {
+    return "";
+  }
+
+  const header = message.split("\n")[0] || "";
+  return header.trim();
+}
+
+function containsBreakingChange(message) {
+  if (typeof message !== "string") {
+    return false;
+  }
+
+  return /breaking change/i.test(message);
+}
+
+export function determineReleaseTypeFromCommit(message) {
+  const header = normalizeCommitHeader(message).toLowerCase();
+  const hasBreaking = containsBreakingChange(message) || /!/.test(header.split(":")[0] || "");
+
+  if (hasBreaking) {
+    return "major";
+  }
+
+  const typeMatch = header.match(/^([a-z]+)(\(|:)/i);
+  const commitType = typeMatch ? typeMatch[1] : "";
+
+  if (commitType === "feat") {
+    return "minor";
+  }
+
+  if (commitType === "fix" || commitType === "perf") {
+    return "patch";
+  }
+
+  if (!commitType && containsBreakingChange(message)) {
+    return "major";
+  }
+
+  return "patch";
+}
+
+async function getLastCommitMessage() {
+  try {
+    const { stdout } = await exec("git log -1 --pretty=%B");
+    return stdout.trim();
+  } catch (error) {
+    return "";
+  }
+}
+
 async function getCurrentBranch() {
   try {
     const { stdout } = await exec("git rev-parse --abbrev-ref HEAD");
@@ -256,6 +539,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {},
         },
       },
+      {
+        name: "skip_tests",
+        description:
+          "Record that tests were intentionally skipped, with a justification.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            reason: {
+              type: "string",
+              description: "Why tests cannot be created or executed",
+            },
+          },
+          required: ["reason"],
+        },
+      },
       {
         name: "run_tests",
         description:
@@ -325,7 +623,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 "Optional branch name to push to (defaults to current branch)",
             },
           },
-          required: ["commitMessage"],
+          required: [],
         },
       },
       {
@@ -362,6 +660,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["commitMessage"],
         },
       },
+      {
+        name: "drop_task",
+        description:
+          "Abandon the current task and reset the workflow without completing it.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            reason: {
+              type: "string",
+              description: "Optional explanation for dropping the task",
+            },
+          },
+        },
+      },
       {
         name: "get_workflow_status",
         description: "Get current workflow status and what needs to be done next.",
@@ -412,6 +724,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         workflowState.state.currentPhase = "coding";
         workflowState.state.taskDescription = args.description;
         workflowState.state.taskType = args.type;
+        workflowState.state.testsSkipped = false;
+        workflowState.state.testsSkippedReason = "";
         workflowState.state.commitAndPushCompleted = false;
         workflowState.state.lastCommitMessage = "";
         workflowState.state.lastPushBranch = "";
@@ -442,12 +756,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         workflowState.state.bugFixed = true;
         workflowState.state.testsCreated = false;
         workflowState.state.currentPhase = "testing";
+        workflowState.state.testsSkipped = false;
+        workflowState.state.testsSkippedReason = "";
         workflowState.state.fixSummary = args.summary;
         workflowState.state.readyCheckCompleted = false;
         workflowState.state.released = false;
         workflowState.state.releaseCommand = "";
         workflowState.state.releaseNotes = "";
-        workflowState.state.readyToCommit = false;
         workflowState.state.commitAndPushCompleted = false;
         workflowState.state.lastCommitMessage = "";
         workflowState.state.lastPushBranch = "";
@@ -476,6 +791,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         workflowState.state.testsCreated = true;
+        workflowState.state.testsSkipped = false;
+        workflowState.state.testsSkippedReason = "";
         workflowState.state.readyCheckCompleted = false;
         workflowState.state.released = false;
         workflowState.state.commitAndPushCompleted = false;
@@ -493,6 +810,78 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      case "skip_tests": {
+        if (workflowState.state.currentPhase === "idle") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ No active task. Use 'start_task' before skipping tests.",
+              },
+            ],
+          };
+        }
+
+        if (!workflowState.state.bugFixed) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please mark your feature/bug as fixed first using 'mark_bug_fixed'!",
+              },
+            ],
+          };
+        }
+
+        const reason =
+          typeof args.reason === "string" ? args.reason.trim() : "";
+
+        if (!reason) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Provide a non-empty justification when skipping tests.",
+              },
+            ],
+          };
+        }
+
+        workflowState.state.testsCreated = true;
+        workflowState.state.testsPassed = true;
+        workflowState.state.testsSkipped = true;
+        workflowState.state.testsSkippedReason = reason;
+        workflowState.state.currentPhase = "documentation";
+        workflowState.state.readyToCommit = false;
+        workflowState.state.readyCheckCompleted = false;
+        workflowState.state.released = false;
+        workflowState.state.commitAndPushCompleted = false;
+        workflowState.state.lastCommitMessage = "";
+        workflowState.state.lastPushBranch = "";
+        await workflowState.save();
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `⚠️ Tests skipped for this task.
+Reason: ${reason}
+
+Manual verification is now required.
+
+Next Steps:
+1. ✓ Fix/implement feature
+2. ⚠️ Tests skipped (ensure manual QA)
+3. ⏳ Create/update documentation
+4. ⏳ Run 'check_ready_to_commit'
+5. ⏳ Commit & push
+6. ⏳ Run 'perform_release'
+7. ⏳ Complete task`,
+            },
+          ],
+        };
+      }
+
       case "run_tests": {
         if (!workflowState.state.bugFixed) {
           return {
@@ -535,6 +924,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         workflowState.state.testCommand = args.testCommand;
         workflowState.state.testDetails =
           typeof args.details === "string" ? args.details : "";
+        workflowState.state.testsSkipped = false;
+        workflowState.state.testsSkippedReason = "";
         workflowState.state.readyCheckCompleted = false;
         workflowState.state.released = false;
         workflowState.state.commitAndPushCompleted = false;
@@ -568,75 +959,86 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
-    case "create_documentation": {
-      if (!workflowState.state.testsPassed) {
+      case "create_documentation": {
+        if (!workflowState.state.testsPassed) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please ensure tests are passing first! Run 'run_tests' with passed=true.",
+              },
+            ],
+          };
+        }
+
+        workflowState.state.documentationCreated = true;
+        workflowState.state.documentationType = args.documentationType;
+        workflowState.state.documentationSummary = args.summary;
+        workflowState.state.currentPhase = "ready";
+        workflowState.state.readyToCommit = true;
+        workflowState.state.readyCheckCompleted = false;
+        workflowState.state.released = false;
+        workflowState.state.commitAndPushCompleted = false;
+        workflowState.state.lastCommitMessage = "";
+        workflowState.state.lastPushBranch = "";
+        await workflowState.save();
+
         return {
           content: [
             {
               type: "text",
-              text: "⚠️ Please ensure tests are passing first! Run 'run_tests' with passed=true.",
+              text: `✅ Documentation created!\n\nType: ${args.documentationType}\nSummary: ${args.summary}\n\n🎉 You're ready to verify your work!\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ✓ Create tests\n3. ✓ Run tests (GREEN!)\n4. ✓ Create documentation\n5. ⏳ Run 'check_ready_to_commit' to verify\n6. ⏳ Commit & push, then run 'perform_release'\n7. ⏳ Mark as complete with 'complete_task'\n\nRemember: git add . && git commit && git push`,
             },
           ],
         };
       }
 
-      workflowState.state.documentationCreated = true;
-      workflowState.state.documentationType = args.documentationType;
-      workflowState.state.documentationSummary = args.summary;
-      workflowState.state.currentPhase = "ready";
-      workflowState.state.readyToCommit = true;
-      workflowState.state.readyCheckCompleted = false;
-      workflowState.state.released = false;
-      workflowState.state.commitAndPushCompleted = false;
-      workflowState.state.lastCommitMessage = "";
-      workflowState.state.lastPushBranch = "";
-      await workflowState.save();
-
-      return {
-        content: [
+      case "check_ready_to_commit": {
+        const status = workflowState.state;
+        const testsCreatedDone = status.testsSkipped || status.testsCreated;
+        const testsPassedDone = status.testsSkipped || status.testsPassed;
+        const checks = [
+          { name: "Task started", done: status.currentPhase !== "idle" },
+          { name: "Feature/bug fixed", done: status.bugFixed },
           {
-            type: "text",
-            text: `✅ Documentation created!\n\nType: ${args.documentationType}\nSummary: ${args.summary}\n\n🎉 You're ready to verify your work!\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ✓ Create tests\n3. ✓ Run tests (GREEN!)\n4. ✓ Create documentation\n5. ⏳ Run 'check_ready_to_commit' to verify\n6. ⏳ Commit & push, then run 'perform_release'\n7. ⏳ Mark as complete with 'complete_task'\n\nRemember: git add . && git commit && git push`,
+            name: status.testsSkipped
+              ? "Tests skipped (manual QA documented)"
+              : "Tests created",
+            done: testsCreatedDone,
           },
-        ],
-      };
-    }
-
-    case "check_ready_to_commit": {
-      const status = workflowState.state;
-      const checks = [
-        { name: "Task started", done: status.currentPhase !== "idle" },
-        { name: "Feature/bug fixed", done: status.bugFixed },
-        { name: "Tests created", done: status.testsCreated },
-        { name: "Tests created and passed", done: status.testsPassed },
-        { name: "Documentation created", done: status.documentationCreated },
-      ];
-
-      const allDone = checks.every((c) => c.done);
-      const checkList = checks
-        .map((c) => `${c.done ? "✅" : "❌"} ${c.name}`)
-        .join("\n");
+          {
+            name: status.testsSkipped ? "Tests skipped acknowledged" : "Tests passed",
+            done: testsPassedDone,
+          },
+          { name: "Documentation created", done: status.documentationCreated },
+        ];
+
+        const allDone = checks.every((c) => c.done);
+        const checkList = checks
+          .map((c) => `${c.done ? "✅" : "❌"} ${c.name}`)
+          .join("\n");
+
+        workflowState.state.readyCheckCompleted = allDone;
+        if (allDone) {
+          workflowState.state.currentPhase = workflowState.state.commitAndPushCompleted
+            ? workflowState.state.released
+              ? "ready_to_complete"
+              : "release"
+            : "commit";
+        }
+        await workflowState.save();
 
-      workflowState.state.readyCheckCompleted = allDone;
-      if (allDone) {
-        workflowState.state.currentPhase = workflowState.state.commitAndPushCompleted
-          ? workflowState.state.released
-            ? "ready_to_complete"
-            : "release"
-          : "commit";
-      }
-      await workflowState.save();
+        if (allDone) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `🎉 ALL CHECKS PASSED!\n\n${checkList}\n\n✅ Next actions:\n1. Run 'commit_and_push' with your commit message\n2. Run 'perform_release' to record the release\n3. Finish with 'complete_task'\n\nTip: Provide the optional 'branch' argument to push to a non-default branch.\n\nTask: ${status.taskDescription}`,
+              },
+            ],
+          };
+        }
 
-      if (allDone) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `🎉 ALL CHECKS PASSED!\n\n${checkList}\n\n✅ Next actions:\n1. Run 'commit_and_push' with your commit message\n2. Run 'perform_release' to record the release\n3. Finish with 'complete_task'\n\nTip: Provide the optional 'branch' argument to push to a non-default branch.\n\nTask: ${status.taskDescription}`,
-            },
-          ],
-        };
-      } else {
         return {
           content: [
             {
@@ -646,301 +1048,243 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           ],
         };
       }
-    }
 
-    case "commit_and_push": {
-      if (!workflowState.state.readyToCommit) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Not ready yet! Run 'check_ready_to_commit' and complete all steps first.",
-            },
-          ],
-        };
-      }
-
-      if (!workflowState.state.readyCheckCompleted) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Please run 'check_ready_to_commit' and resolve any outstanding items before committing!",
-            },
-          ],
-        };
-      }
-
-      const commitMessage =
-        typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
-
-      if (!commitMessage) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Please provide a non-empty 'commitMessage' when using 'commit_and_push'.",
-            },
-          ],
-        };
-      }
+      case "commit_and_push": {
+        if (!workflowState.state.readyToCommit) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Not ready yet! Run 'check_ready_to_commit' and complete all steps first.",
+              },
+            ],
+          };
+        }
 
-      if (!(await hasWorkingChanges())) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ No changes detected. Make sure you have modifications to commit before running 'commit_and_push'.",
-            },
-          ],
-        };
-      }
+        if (!workflowState.state.readyCheckCompleted) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please run 'check_ready_to_commit' and resolve any outstanding items before committing!",
+              },
+            ],
+          };
+        }
 
-      try {
-        await exec("git add .");
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `❌ Failed to stage files:\n\n${error.stderr || error.stdout || error.message}`,
-            },
-          ],
-        };
-      }
+        const providedCommitMessage =
+          typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
 
-      try {
-        await exec(`git commit -m ${shellEscape(commitMessage)}`);
-      } catch (error) {
-        const output = error.stderr || error.stdout || error.message || "Unknown error";
-        if (output.includes("nothing to commit")) {
+        if (!(await hasWorkingChanges())) {
           return {
             content: [
               {
                 type: "text",
-                text: "⚠️ Nothing to commit. Make additional changes before running 'commit_and_push'.",
+                text: "⚠️ No changes detected. Make sure you have modifications to commit before running 'commit_and_push'.",
               },
             ],
           };
         }
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: `❌ git commit failed:\n\n${output}`,
-            },
-          ],
-        };
-      }
-
-      const requestedBranch =
-        typeof args.branch === "string" ? args.branch.trim() : "";
-      const currentBranch = await getCurrentBranch();
-      const pushBranch = requestedBranch || currentBranch;
-      const pushCommand = pushBranch
-        ? `git push origin ${shellEscape(pushBranch)}`
-        : "git push";
-
-      try {
-        await exec(pushCommand);
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `❌ git push failed:\n\n${error.stderr || error.stdout || error.message}`,
-            },
-          ],
-        };
-      }
+        if (!(await hasTestChanges()) && !workflowState.state.testsSkipped) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please include test updates in your changes before running 'commit_and_push'. Ensure at least one test file is modified.",
+              },
+            ],
+          };
+        }
 
-      workflowState.state.commitAndPushCompleted = true;
-      workflowState.state.lastCommitMessage = commitMessage;
-      workflowState.state.lastPushBranch = pushBranch || currentBranch || "";
-      workflowState.state.currentPhase = workflowState.state.released
-        ? "ready_to_complete"
-        : "release";
-      await workflowState.save();
+        try {
+          await exec("git add .");
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `❌ Failed to stage files:\n\n${error.stderr || error.stdout || error.message}`,
+              },
+            ],
+          };
+        }
 
-      return {
-        content: [
-          {
-            type: "text",
-            text: `✅ Commit & push completed!\n\nCommit message: ${commitMessage}\nPushed to: ${pushBranch || currentBranch || "(default upstream)"}\n\nNext: Run 'perform_release' to record the release.`,
-          },
-        ],
-      };
-    }
+        const stagedChanges = await getStagedChanges();
+        const { summary: generatedSummary, body: commitBody } =
+          createCommitMessageParts(stagedChanges, providedCommitMessage);
 
-    case "perform_release": {
-      if (workflowState.state.currentPhase === "idle") {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Please start a task first using 'start_task'!",
-            },
-          ],
-        };
-      }
+        if (!generatedSummary) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Unable to generate commit message. Please provide a 'commitMessage' manually.",
+              },
+            ],
+          };
+        }
 
-      if (!workflowState.state.commitAndPushCompleted) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Please run 'commit_and_push' after the ready check before recording a release!",
-            },
-          ],
-        };
-      }
+        try {
+          if (commitBody) {
+            await exec(
+              `git commit -m ${shellEscape(generatedSummary)} -m ${shellEscape(commitBody)}`
+            );
+          } else {
+            await exec(`git commit -m ${shellEscape(generatedSummary)}`);
+          }
+        } catch (error) {
+          const output = error.stderr || error.stdout || error.message || "Unknown error";
+          if (output.includes("nothing to commit")) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "⚠️ Nothing to commit. Make additional changes before running 'commit_and_push'.",
+                },
+              ],
+            };
+          }
 
-      if (!workflowState.state.readyCheckCompleted) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Please run 'check_ready_to_commit' and ensure all checks pass before releasing!",
-            },
-          ],
-        };
-      }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `❌ git commit failed:\n\n${output}`,
+              },
+            ],
+          };
+        }
 
-      workflowState.state.released = true;
-      workflowState.state.releaseCommand = args.command;
-      workflowState.state.releaseNotes =
-        typeof args.notes === "string" ? args.notes : "";
-      workflowState.state.currentPhase = "ready_to_complete";
-      await workflowState.save();
+        const requestedBranch =
+          typeof args.branch === "string" ? args.branch.trim() : "";
+        const currentBranch = await getCurrentBranch();
+        const pushCommand = requestedBranch
+          ? `git push origin ${shellEscape(requestedBranch)}`
+          : "git push";
 
-      return {
-        content: [
-          {
-            type: "text",
-            text: `🚀 Release recorded!\n\nCommand: ${args.command}\n${workflowState.state.releaseNotes ? `Notes: ${workflowState.state.releaseNotes}\n` : ""}\n✅ Next: Run 'complete_task' to wrap up.`,
-          },
-        ],
-      };
-    }
+        try {
+          await exec(pushCommand);
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `❌ git push failed:\n\n${error.stderr || error.stdout || error.message}`,
+              },
+            ],
+          };
+        }
 
-    case "complete_task": {
-      if (!workflowState.state.readyToCommit) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Not ready to complete! Run 'check_ready_to_commit' first.",
-            },
-          ],
-        };
-      }
+        workflowState.state.commitAndPushCompleted = true;
+        workflowState.state.lastCommitMessage = generatedSummary;
+        workflowState.state.lastPushBranch =
+          requestedBranch || currentBranch || "";
+        workflowState.state.currentPhase = workflowState.state.released
+          ? "ready_to_complete"
+          : "release";
+        await workflowState.save();
 
-      if (!workflowState.state.readyCheckCompleted) {
         return {
           content: [
             {
               type: "text",
-              text: "⚠️ Please run 'check_ready_to_commit' and ensure all checks pass before completing the task!",
+              text: `✅ Commit & push completed!\n\nCommit message: ${generatedSummary}\nPushed to: ${
+                requestedBranch || currentBranch || "(default upstream)"
+              }\n\nNext: Run 'perform_release' to record the release.`,
             },
           ],
         };
       }
 
-      if (!workflowState.state.commitAndPushCompleted) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Commit and push not completed! Run 'commit_and_push' first.",
-            },
-          ],
-        };
-      }
+      case "perform_release": {
+        if (workflowState.state.currentPhase === "idle") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please start a task first using 'start_task'!",
+              },
+            ],
+          };
+        }
 
-      if (!workflowState.state.released) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Release not recorded! Run 'perform_release' after committing and pushing.",
-            },
-          ],
-        };
-      }
+        if (!workflowState.state.commitAndPushCompleted) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please run 'commit_and_push' after the ready check before recording a release!",
+              },
+            ],
+          };
+        }
 
-      if (await hasStagedChanges()) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "⚠️ Staged files detected! Please commit or unstage all files before pushing. Run 'git status' to confirm a clean working tree, then try again.",
-            },
-          ],
-        };
-      }
+        if (!workflowState.state.readyCheckCompleted) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please run 'check_ready_to_commit' and ensure all checks pass before releasing!",
+              },
+            ],
+          };
+        }
 
-      workflowState.addToHistory({
-        taskDescription: workflowState.state.taskDescription,
-        taskType: workflowState.state.taskType,
-        fixSummary: workflowState.state.fixSummary,
-        testCommand: workflowState.state.testCommand,
-        documentationType: workflowState.state.documentationType,
-        commitMessage: args.commitMessage,
-        releaseCommand: workflowState.state.releaseCommand,
-        releaseNotes: workflowState.state.releaseNotes,
-      });
+        const releaseCommand =
+          typeof args.command === "string" ? args.command.trim() : "";
 
-      const completedTask = workflowState.state.taskDescription;
-      workflowState.reset();
-      workflowState.state.currentPhase = "idle";
-      await workflowState.save();
+        if (!releaseCommand) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please provide a non-empty 'command' when using 'perform_release'.",
+              },
+            ],
+          };
+        }
 
-      return {
-        content: [
-          {
-            type: "text",
-            text: `🎉 Task completed successfully!\n\nCompleted: ${completedTask}\nCommit: ${args.commitMessage}\n\n✅ Workflow reset. Ready for next task!\n\nUse 'start_task' when you begin your next coding session.`,
-          },
-        ],
-      };
-    }
+        if (await hasWorkingChanges()) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Working tree not clean! Please commit or stash all changes before running 'perform_release'.",
+              },
+            ],
+          };
+        }
 
-    case "get_workflow_status": {
-      const status = workflowState.state;
+        const lastCommitMessage = await getLastCommitMessage();
+        const releaseType = determineReleaseTypeFromCommit(
+          lastCommitMessage || workflowState.state.lastCommitMessage
+        );
 
-      if (status.currentPhase === "idle") {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "📋 No active task.\n\nUse 'start_task' to begin a new coding session.",
-            },
-          ],
-        };
-      }
+        const finalCommand = releaseCommand.includes("--release-as")
+          ? releaseCommand
+          : `${releaseCommand} -- --release-as ${releaseType}`;
 
-      const phaseMessages = {
-        coding: "🔨 Currently coding",
-        testing: "🧪 Ready for testing",
-        documentation: "📝 Ready for documentation",
-        ready: "✅ Ready for verification",
-        commit: "📦 Ready to commit & push",
-        release: "🚀 Ready to release",
-        ready_to_complete: "✅ Release completed",
-      };
+        try {
+          await exec(finalCommand);
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `❌ Release command failed:\n\n${error.stderr || error.stdout || error.message}`,
+              },
+            ],
+          };
+        }
 
-      return {
-        content: [
-          {
-            type: "text",
-            text: `📋 Current Workflow Status\n\nTask: ${status.taskDescription}\nPhase: ${phaseMessages[status.currentPhase]}\n\nProgress:\n${status.bugFixed ? "✅" : "⏳"} Feature/bug fixed\n${status.testsCreated ? "✅" : "⏳"} Tests created\n${status.testsPassed ? "✅" : "⏳"} Tests passed\n${status.documentationCreated ? "✅" : "⏳"} Documentation created\n${status.readyCheckCompleted ? "✅" : "⏳"} Ready check completed\n${status.commitAndPushCompleted ? "✅" : "⏳"} Commit & push completed\n${status.released ? "✅" : "⏳"} Release recorded\n\nNext: ${getNextStep(status)}`,
-          },
-        ],
-      };
-    }
+        workflowState.state.released = true;
+        workflowState.state.releaseCommand = finalCommand;
+        workflowState.state.releaseNotes =
+          typeof args.notes === "string" ? args.notes : "";
+        workflowState.state.currentPhase = "ready_to_complete";
+        await workflowState.save();
 
-    case "view_history": {
       const limit = args.limit || 10;
       const history = workflowState.state.history.slice(-limit).reverse();