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

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [1.0.7](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.6...v1.0.7) (2025-10-20)
+
+### [1.0.6](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.5...v1.0.6) (2025-10-20)
+
+
+### ✅ Tests
+
+* enforce clean release workflow ([c261a7b](https://github.com/programinglive/dev-workflow-mcp-server/commit/c261a7b3d141ba4472567bd47e4f6b6e4d2ee3fd))
+
+### [1.0.5](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.4...v1.0.5) (2025-10-20)
+
+
+### ✅ Tests
+
+* update index.js and tests/workflowState.test.js ([b9df3c8](https://github.com/programinglive/dev-workflow-mcp-server/commit/b9df3c8643303769dbe4c5a0992995b6328cdfcf))
+
 ### [1.0.4](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.3...v1.0.4) (2025-10-20)
 
 

package/index.js

@@ -186,6 +186,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");
@@ -325,7 +598,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 "Optional branch name to push to (defaults to current branch)",
             },
           },
-          required: ["commitMessage"],
+          required: [],
         },
       },
       {
@@ -671,26 +944,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
-      const commitMessage =
+      const providedCommitMessage =
         typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
 
-      if (!commitMessage) {
+      if (!(await hasWorkingChanges())) {
         return {
           content: [
             {
               type: "text",
-              text: "⚠️ Please provide a non-empty 'commitMessage' when using 'commit_and_push'.",
+              text: "⚠️ No changes detected. Make sure you have modifications to commit before running 'commit_and_push'.",
             },
           ],
         };
       }
 
-      if (!(await hasWorkingChanges())) {
+      if (!(await hasTestChanges())) {
         return {
           content: [
             {
               type: "text",
-              text: "⚠️ No changes detected. Make sure you have modifications to commit before running 'commit_and_push'.",
+              text: "⚠️ Please include test updates in your changes before running 'commit_and_push'. Ensure at least one test file is modified.",
             },
           ],
         };
@@ -709,8 +982,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      const stagedChanges = await getStagedChanges();
+      const { summary: generatedSummary, body: commitBody } =
+        createCommitMessageParts(stagedChanges, providedCommitMessage);
+
+      if (!generatedSummary) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Unable to generate commit message. Please provide a 'commitMessage' manually.",
+            },
+          ],
+        };
+      }
+
       try {
-        await exec(`git commit -m ${shellEscape(commitMessage)}`);
+        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")) {
@@ -737,9 +1031,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       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)}`
+      const pushCommand = requestedBranch
+        ? `git push origin ${shellEscape(requestedBranch)}`
         : "git push";
 
       try {
@@ -756,8 +1049,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
 
       workflowState.state.commitAndPushCompleted = true;
-      workflowState.state.lastCommitMessage = commitMessage;
-      workflowState.state.lastPushBranch = pushBranch || currentBranch || "";
+      workflowState.state.lastCommitMessage = generatedSummary;
+      workflowState.state.lastPushBranch =
+        requestedBranch || currentBranch || "";
       workflowState.state.currentPhase = workflowState.state.released
         ? "ready_to_complete"
         : "release";
@@ -767,7 +1061,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         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.`,
+            text: `✅ Commit & push completed!\n\nCommit message: ${generatedSummary}\nPushed to: ${
+              requestedBranch || currentBranch || "(default upstream)"
+            }\n\nNext: Run 'perform_release' to record the release.`,
           },
         ],
       };
@@ -807,8 +1103,55 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      const releaseCommand =
+        typeof args.command === "string" ? args.command.trim() : "";
+
+      if (!releaseCommand) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Please provide a non-empty 'command' when using 'perform_release'.",
+            },
+          ],
+        };
+      }
+
+      if (await hasWorkingChanges()) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Working tree not clean! Please commit or stash all changes before running 'perform_release'.",
+            },
+          ],
+        };
+      }
+
+      const lastCommitMessage = await getLastCommitMessage();
+      const releaseType = determineReleaseTypeFromCommit(
+        lastCommitMessage || workflowState.state.lastCommitMessage
+      );
+
+      const finalCommand = releaseCommand.includes("--release-as")
+        ? releaseCommand
+        : `${releaseCommand} -- --release-as ${releaseType}`;
+
+      try {
+        await exec(finalCommand);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `❌ Release command failed:\n\n${error.stderr || error.stdout || error.message}`,
+            },
+          ],
+        };
+      }
+
       workflowState.state.released = true;
-      workflowState.state.releaseCommand = args.command;
+      workflowState.state.releaseCommand = finalCommand;
       workflowState.state.releaseNotes =
         typeof args.notes === "string" ? args.notes : "";
       workflowState.state.currentPhase = "ready_to_complete";
@@ -818,7 +1161,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         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.`,
+            text: `🚀 Release recorded!\n\nCommand: ${finalCommand}\nRelease type: ${releaseType}\n${workflowState.state.releaseNotes ? `Notes: ${workflowState.state.releaseNotes}\n` : ""}\n✅ Next: Run 'complete_task' to wrap up.`,
           },
         ],
       };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "MCP server to enforce development workflow discipline",
   "type": "module",
   "main": "index.js",

package/tests/workflowState.test.js

@@ -3,7 +3,14 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import { WorkflowState, getNextStep } from "../index.js";
+import {
+  WorkflowState,
+  getNextStep,
+  containsTestFilesInStatus,
+  createCommitMessageParts,
+  determineReleaseTypeFromCommit,
+  workingTreeSummary,
+} from "../index.js";
 
 async function withWorkflowState(callback) {
   const tempDir = await mkdtemp(path.join(tmpdir(), "workflow-state-"));
@@ -118,3 +125,80 @@ test("getNextStep guides workflow progression", () => {
   const afterRelease = { ...afterCommit, released: true };
   assert.equal(getNextStep(afterRelease), "Complete the task");
 });
+
+test("containsTestFilesInStatus detects modified test files", () => {
+  const statusOutput = [
+    " M src/app.test.js",
+    "A  tests/helpers/util.js",
+    "R  src/old.js -> src/new.spec.ts",
+  ].join("\n");
+
+  assert.equal(containsTestFilesInStatus(statusOutput), true);
+});
+
+test("containsTestFilesInStatus returns false when no test files present", () => {
+  const statusOutput = [
+    " M src/app.js",
+    "A  docs/README.md",
+    "?? assets/logo.png",
+  ].join("\n");
+
+  assert.equal(containsTestFilesInStatus(statusOutput), false);
+});
+
+test("createCommitMessageParts generates test prefixed summary with details", () => {
+  const changes = [
+    { status: "M", path: "src/app.test.js" },
+    { status: "A", path: "tests/helpers/util.js" },
+  ];
+
+  const { summary, body } = createCommitMessageParts(changes);
+
+  assert.equal(summary.startsWith("test:"), true);
+  assert.equal(body.includes("- modified src/app.test.js"), true);
+  assert.equal(body.includes("- added tests/helpers/util.js"), true);
+});
+
+test("createCommitMessageParts respects provided summary when present", () => {
+  const changes = [{ status: "M", path: "docs/guide.md" }];
+  const provided = "docs: update guide";
+
+  const { summary, body } = createCommitMessageParts(changes, provided);
+
+  assert.equal(summary, provided);
+  assert.equal(body.includes("- modified docs/guide.md"), true);
+});
+
+test("determineReleaseTypeFromCommit returns major for breaking change", () => {
+  const message = "feat!: overhaul API\n\nBREAKING CHANGE: new behavior";
+  assert.equal(determineReleaseTypeFromCommit(message), "major");
+});
+
+test("determineReleaseTypeFromCommit returns minor for feat", () => {
+  const message = "feat: add dashboard";
+  assert.equal(determineReleaseTypeFromCommit(message), "minor");
+});
+
+test("determineReleaseTypeFromCommit returns patch for fix", () => {
+  const message = "fix: resolve login issue";
+  assert.equal(determineReleaseTypeFromCommit(message), "patch");
+});
+
+test("determineReleaseTypeFromCommit defaults to patch for other commit types", () => {
+  const message = "chore: update dependencies";
+  assert.equal(determineReleaseTypeFromCommit(message), "patch");
+});
+
+test("workingTreeSummary reports no changes for empty output", () => {
+  const summary = workingTreeSummary("\n  \n");
+  assert.equal(summary.hasChanges, false);
+  assert.deepEqual(summary.lines, []);
+});
+
+test("workingTreeSummary lists trimmed status lines", () => {
+  const statusOutput = " M src/app.js\nA  tests/new.test.js\n";
+  const summary = workingTreeSummary(statusOutput);
+
+  assert.equal(summary.hasChanges, true);
+  assert.deepEqual(summary.lines, ["M src/app.js", "A tests/new.test.js"]);
+});