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

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 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)
+
+
+### ✨ Features
+
+* enforce release step after ready check ([0725496](https://github.com/programinglive/dev-workflow-mcp-server/commit/07254967becd515cb2a4261d62af01dfeb842175))
+
+
+### 🐛 Bug Fixes
+
+* support windows-friendly commit quoting ([47881fd](https://github.com/programinglive/dev-workflow-mcp-server/commit/47881fd0db54da3fabe368b1a135902e47ef873e))
+
+### [1.0.3](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.2...v1.0.3) (2025-10-20)
+
+
+### 🧹 Chores
+
+* add gitignore ([5f695fb](https://github.com/programinglive/dev-workflow-mcp-server/commit/5f695fbc71515c7f1ffbc44fd74b52314c966ee6))
+
+
+### 📝 Documentation
+
+* clarify cross-platform installation ([52b5ee7](https://github.com/programinglive/dev-workflow-mcp-server/commit/52b5ee7061e8f968ff94e6c226586fc1b7e2a057))
+
 ### [1.0.2](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.0.1...v1.0.2) (2025-10-19)
 
 

package/README.md

@@ -11,7 +11,8 @@ This MCP server guides you through a disciplined development workflow:
 3. **Create Tests** - Always test your changes
 4. **Run Tests** - Tests must pass (GREEN)
 5. **Document** - Update documentation
-6. **Commit & Push** - Only when all steps are complete
+6. **Commit & Push** - Let the server drive the git commands once verification passes
+7. **Release** - Record the release details before closing out the task
 
 ## 🚀 Installation
 
@@ -23,34 +24,94 @@ npm install
 
 ### 2. Configure in Windsurf/Claude Desktop
 
-Add to your MCP settings file:
+Point your MCP client to the server entry point. Replace `<PROJECT_ROOT>` with the absolute path to this repository on your machine.
 
-**For Windsurf** (`~/Library/Application Support/Windsurf/config.json`):
+#### macOS
+
+- **Windsurf** (`~/Library/Application Support/Windsurf/config.json`):
+
+```json
+{
+  "mcpServers": {
+    "dev-workflow": {
+      "command": "node",
+      "args": ["<PROJECT_ROOT>/index.js"]
+    }
+  }
+}
+```
+
+- **Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "dev-workflow": {
+      "command": "node",
+      "args": ["<PROJECT_ROOT>/index.js"]
+    }
+  }
+}
+```
+
+#### Windows
+
+- **Windsurf** (`%APPDATA%\Windsurf\config.json`):
+
+```json
+{
+  "mcpServers": {
+    "dev-workflow": {
+      "command": "node",
+      "args": ["<PROJECT_ROOT>\\index.js"]
+    }
+  }
+}
+```
+
+- **Claude Desktop** (`%APPDATA%\Claude\claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "dev-workflow": {
+      "command": "node",
+      "args": ["<PROJECT_ROOT>\\index.js"]
+    }
+  }
+}
+```
+
+#### Linux
+
+- **Windsurf** (`~/.config/windsurf/config.json`):
 
 ```json
 {
   "mcpServers": {
     "dev-workflow": {
       "command": "node",
-      "args": ["/Users/mahardhika/code/project/mine/app/CascadeProjects/windsurf-project/index.js"]
+      "args": ["<PROJECT_ROOT>/index.js"]
     }
   }
 }
 ```
 
-**For Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+- **Claude Desktop** (`~/.config/claude/claude_desktop_config.json`):
 
 ```json
 {
   "mcpServers": {
     "dev-workflow": {
       "command": "node",
-      "args": ["/Users/mahardhika/code/project/mine/app/CascadeProjects/windsurf-project/index.js"]
+      "args": ["<PROJECT_ROOT>/index.js"]
     }
   }
 }
 ```
 
+> **Note:** On Windows paths in JSON require escaped backslashes (e.g., `"C:\\path\\to\\project"`).
+
 ### 3. Restart Windsurf/Claude Desktop
 
 After adding the configuration, restart the application to load the MCP server.
@@ -92,6 +153,11 @@ Mark that the bug/feature is fixed. **Reminder: Now you MUST create tests!**
 **Parameters:**
 - `summary` (string, required): Brief summary of what was fixed/implemented
 
+### `create_tests`
+Confirm that you've created the necessary tests covering your change. Required before recording test results.
+
+**Parameters:** _none_
+
 ### `run_tests`
 Record test results. **NEVER commit if tests fail!** Only proceed if all tests are green.
 
@@ -118,6 +184,20 @@ Mark that documentation has been created/updated. This is required before commit
 ### `check_ready_to_commit`
 Check if all workflow steps are completed and you're ready to commit & push.
 
+### `commit_and_push`
+Automatically run `git add`, `git commit`, and `git push` after the ready check passes.
+
+**Parameters:**
+- `commitMessage` (string, required): Conventional commit message to use
+- `branch` (string, optional): Target branch to push (defaults to current branch)
+
+### `perform_release`
+Record the release after you've committed and pushed. Required before you can complete the task.
+
+**Parameters:**
+- `command` (string, required): Release command that was executed (e.g., `npm run release`)
+- `notes` (string, optional): Additional release notes
+
 ### `complete_task`
 Mark the task as complete after successful commit & push. Resets workflow for next task.
 
@@ -180,13 +260,16 @@ Here's how you'd use this MCP server in a typical coding session:
    ```
 
 8. **Commit & Push:**
-   ```bash
-   git add .
-   git commit -m "feat: add user profile page with tests and docs"
-   git push
+   ```
+   "Commit and push: commitMessage='feat: add user profile page with tests and docs'"
+   ```
+
+9. **Record release:**
+   ```
+   "Record release: command='npm run release', notes='v1.2.3'"
    ```
 
-9. **Complete:**
+10. **Complete:**
    ```
    "Complete the task with commit message: 'feat: add user profile page'"
    ```

package/index.js

@@ -25,9 +25,17 @@ export class WorkflowState {
       currentPhase: "idle",
       taskDescription: "",
       bugFixed: false,
+      testsCreated: false,
       testsPassed: false,
       documentationCreated: false,
       readyToCommit: false,
+      readyCheckCompleted: false,
+      released: false,
+      releaseCommand: "",
+      releaseNotes: "",
+      commitAndPushCompleted: false,
+      lastCommitMessage: "",
+      lastPushBranch: "",
       history: [],
     };
   }
@@ -35,7 +43,35 @@ export class WorkflowState {
   async load() {
     try {
       const data = await fs.readFile(this.stateFile, "utf-8");
-      this.state = JSON.parse(data);
+      const parsed = JSON.parse(data);
+      this.state = {
+        ...this.state,
+        ...parsed,
+      };
+      if (typeof this.state.testsCreated !== "boolean") {
+        this.state.testsCreated = false;
+      }
+      if (typeof this.state.readyCheckCompleted !== "boolean") {
+        this.state.readyCheckCompleted = false;
+      }
+      if (typeof this.state.released !== "boolean") {
+        this.state.released = false;
+      }
+      if (typeof this.state.commitAndPushCompleted !== "boolean") {
+        this.state.commitAndPushCompleted = false;
+      }
+      if (typeof this.state.releaseCommand !== "string") {
+        this.state.releaseCommand = "";
+      }
+      if (typeof this.state.releaseNotes !== "string") {
+        this.state.releaseNotes = "";
+      }
+      if (typeof this.state.lastCommitMessage !== "string") {
+        this.state.lastCommitMessage = "";
+      }
+      if (typeof this.state.lastPushBranch !== "string") {
+        this.state.lastPushBranch = "";
+      }
     } catch (error) {
       // File doesn't exist yet, use default state
     }
@@ -50,9 +86,17 @@ export class WorkflowState {
       currentPhase: "idle",
       taskDescription: "",
       bugFixed: false,
+      testsCreated: false,
       testsPassed: false,
       documentationCreated: false,
       readyToCommit: false,
+      readyCheckCompleted: false,
+      released: false,
+      releaseCommand: "",
+      releaseNotes: "",
+      commitAndPushCompleted: false,
+      lastCommitMessage: "",
+      lastPushBranch: "",
       history: this.state.history,
     };
   }
@@ -70,6 +114,18 @@ await workflowState.load();
 
 const exec = promisify(execCallback);
 
+const isWindows = process.platform === "win32";
+
+function shellEscape(value) {
+  const stringValue = String(value);
+  if (isWindows) {
+    // Use PowerShell-friendly single quotes, escape embedded single quotes by doubling
+    return `'${stringValue.replace(/'/g, "''")}'`;
+  }
+
+  return `'${stringValue.replace(/'/g, "'\\''")}'`;
+}
+
 function normalizeRequestArgs(rawArgs) {
   if (rawArgs === undefined || rawArgs === null) {
     return { args: {}, error: null };
@@ -121,6 +177,297 @@ async function hasStagedChanges() {
   }
 }
 
+async function hasWorkingChanges() {
+  try {
+    const { stdout } = await exec("git status --porcelain");
+    return stdout.split("\n").some((line) => line && line.trim().length > 0);
+  } catch (error) {
+    return false;
+  }
+}
+
+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");
+    return stdout.trim();
+  } catch (error) {
+    return "";
+  }
+}
+
 // Create MCP server
 export const server = new Server(
   {
@@ -174,6 +521,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["summary"],
         },
       },
+      {
+        name: "create_tests",
+        description: "Mark that tests covering the change have been created.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
       {
         name: "run_tests",
         description:
@@ -226,6 +581,45 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           properties: {},
         },
       },
+      {
+        name: "commit_and_push",
+        description:
+          "Automatically run git add, commit, and push once the ready check passes.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            commitMessage: {
+              type: "string",
+              description: "Commit message to use",
+            },
+            branch: {
+              type: "string",
+              description:
+                "Optional branch name to push to (defaults to current branch)",
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "perform_release",
+        description:
+          "Record release details after committing and pushing your changes.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            command: {
+              type: "string",
+              description: "Release command that was executed",
+            },
+            notes: {
+              type: "string",
+              description: "Optional release notes",
+            },
+          },
+          required: ["command"],
+        },
+      },
       {
         name: "complete_task",
         description:
@@ -291,13 +685,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         workflowState.state.currentPhase = "coding";
         workflowState.state.taskDescription = args.description;
         workflowState.state.taskType = args.type;
+        workflowState.state.commitAndPushCompleted = false;
+        workflowState.state.lastCommitMessage = "";
+        workflowState.state.lastPushBranch = "";
         await workflowState.save();
 
         return {
           content: [
             {
               type: "text",
-              text: `✅ Task Started: ${args.description}\n\n🎯 Be conscious about what you're coding!\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Fix/implement the feature\n3. ⏳ Create tests\n4. ⏳ Run tests (must pass!)\n5. ⏳ Create documentation\n6. ⏳ Commit & push\n\nReminder: Focus on writing clean, maintainable code!`,
+              text: `✅ Task Started: ${args.description}\n\n🎯 Be conscious about what you're coding!\n\nWorkflow Steps:\n1. ✓ Start task (current)\n2. ⏳ Fix/implement the feature\n3. ⏳ Create tests\n4. ⏳ Run tests (must pass!)\n5. ⏳ Create documentation\n6. ⏳ Run 'check_ready_to_commit'\n7. ⏳ Commit & push, then run 'perform_release'\n8. ⏳ Complete task\n\nReminder: Focus on writing clean, maintainable code!`,
             },
           ],
         };
@@ -316,15 +713,54 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
 
         workflowState.state.bugFixed = true;
+        workflowState.state.testsCreated = false;
         workflowState.state.currentPhase = "testing";
         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 = "";
         await workflowState.save();
 
         return {
           content: [
             {
               type: "text",
-              text: `✅ Feature/Bug marked as fixed!\n\n⚠️ CRITICAL REMINDER: You MUST create tests now!\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ⏳ Create tests for: ${args.summary}\n3. ⏳ Run tests (must be green!)\n4. ⏳ Create documentation\n5. ⏳ Commit & push\n\n🚫 DO NOT SKIP TESTING!`,
+              text: `✅ Feature/Bug marked as fixed!\n\n⚠️ CRITICAL REMINDER: You MUST create tests now!\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ⏳ Create tests for: ${args.summary}\n3. ⏳ Run tests (must be green!)\n4. ⏳ Create documentation\n5. ⏳ Run 'check_ready_to_commit'\n6. ⏳ Commit & push, then run 'perform_release'\n7. ⏳ Complete task\n\n🚫 DO NOT SKIP TESTING!`,
+            },
+          ],
+        };
+      }
+
+      case "create_tests": {
+        if (!workflowState.state.bugFixed) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please mark your feature/bug as fixed first using 'mark_bug_fixed'!",
+              },
+            ],
+          };
+        }
+
+        workflowState.state.testsCreated = 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: "✅ Tests recorded!\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ✓ Create tests\n3. ⏳ Run tests (must be green!)\n4. ⏳ Create documentation\n5. ⏳ Run 'check_ready_to_commit'\n6. ⏳ Commit & push, then run 'perform_release'\n7. ⏳ Complete task\n\n🧪 Run your test command and record the results using 'run_tests'.",
             },
           ],
         };
@@ -342,6 +778,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           };
         }
 
+        if (!workflowState.state.testsCreated) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "⚠️ Please create tests first using 'create_tests' before recording test results!",
+              },
+            ],
+          };
+        }
+
         if (
           typeof args.passed !== "boolean" ||
           typeof args.testCommand !== "string" ||
@@ -361,6 +808,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         workflowState.state.testCommand = args.testCommand;
         workflowState.state.testDetails =
           typeof args.details === "string" ? args.details : "";
+        workflowState.state.readyCheckCompleted = false;
+        workflowState.state.released = false;
+        workflowState.state.commitAndPushCompleted = false;
+        workflowState.state.lastCommitMessage = "";
+        workflowState.state.lastPushBranch = "";
 
         if (!args.passed) {
           workflowState.state.currentPhase = "testing";
@@ -383,7 +835,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           content: [
             {
               type: "text",
-              text: `✅ All tests passed! 🎉\n\nTest command: ${args.testCommand}\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ✓ Create tests\n3. ✓ Run tests (GREEN!)\n4. ⏳ Create/update documentation\n5. ⏳ Commit & push\n\nReminder: Document what you did before committing!`,
+              text: `✅ All tests passed! 🎉\n\nTest command: ${args.testCommand}\n\nNext Steps:\n1. ✓ Fix/implement feature\n2. ✓ Create tests\n3. ✓ Run tests (GREEN!)\n4. ⏳ Create/update documentation\n5. ⏳ Run 'check_ready_to_commit'\n6. ⏳ Commit & push, then run 'perform_release'\n7. ⏳ Complete task\n\nReminder: Document what you did before committing!`,
             },
           ],
         };
@@ -406,13 +858,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       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: `✅ Documentation created!\n\nType: ${args.documentationType}\nSummary: ${args.summary}\n\n🎉 You're ready to commit!\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\n7. ⏳ Mark as complete with 'complete_task'\n\nRemember: git add . && git commit && git push`,
+            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`,
           },
         ],
       };
@@ -423,6 +880,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       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 },
       ];
@@ -432,12 +890,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         .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();
+
       if (allDone) {
         return {
           content: [
             {
               type: "text",
-              text: `🎉 ALL CHECKS PASSED! You're ready to commit!\n\n${checkList}\n\n✅ You can now:\n1. git add .\n2. git commit -m "your message"\n3. git push\n4. Run 'complete_task' to finish\n\nTask: ${status.taskDescription}`,
+              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}`,
             },
           ],
         };
@@ -453,6 +921,252 @@ 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 providedCommitMessage =
+        typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
+
+      if (!(await hasWorkingChanges())) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ No changes detected. Make sure you have modifications to commit before running 'commit_and_push'.",
+            },
+          ],
+        };
+      }
+
+      if (!(await hasTestChanges())) {
+        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.",
+            },
+          ],
+        };
+      }
+
+      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 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 {
+        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'.",
+              },
+            ],
+          };
+        }
+
+        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 pushCommand = requestedBranch
+        ? `git push origin ${shellEscape(requestedBranch)}`
+        : "git push";
+
+      try {
+        await exec(pushCommand);
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `❌ git push failed:\n\n${error.stderr || error.stdout || error.message}`,
+            },
+          ],
+        };
+      }
+
+      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();
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `✅ Commit & push completed!\n\nCommit message: ${generatedSummary}\nPushed to: ${
+              requestedBranch || currentBranch || "(default upstream)"
+            }\n\nNext: Run 'perform_release' to record the release.`,
+          },
+        ],
+      };
+    }
+
+    case "perform_release": {
+      if (workflowState.state.currentPhase === "idle") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Please start a task first using 'start_task'!",
+            },
+          ],
+        };
+      }
+
+      if (!workflowState.state.commitAndPushCompleted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Please run 'commit_and_push' after the ready check before recording a release!",
+            },
+          ],
+        };
+      }
+
+      if (!workflowState.state.readyCheckCompleted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Please run 'check_ready_to_commit' and ensure all checks pass before releasing!",
+            },
+          ],
+        };
+      }
+
+      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 = finalCommand;
+      workflowState.state.releaseNotes =
+        typeof args.notes === "string" ? args.notes : "";
+      workflowState.state.currentPhase = "ready_to_complete";
+      await workflowState.save();
+
+      return {
+        content: [
+          {
+            type: "text",
+            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.`,
+          },
+        ],
+      };
+    }
+
     case "complete_task": {
       if (!workflowState.state.readyToCommit) {
         return {
@@ -465,6 +1179,39 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
       }
 
+      if (!workflowState.state.readyCheckCompleted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Please run 'check_ready_to_commit' and ensure all checks pass before completing the task!",
+            },
+          ],
+        };
+      }
+
+      if (!workflowState.state.commitAndPushCompleted) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Commit and push not completed! Run 'commit_and_push' first.",
+            },
+          ],
+        };
+      }
+
+      if (!workflowState.state.released) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "⚠️ Release not recorded! Run 'perform_release' after committing and pushing.",
+            },
+          ],
+        };
+      }
+
       if (await hasStagedChanges()) {
         return {
           content: [
@@ -483,6 +1230,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         testCommand: workflowState.state.testCommand,
         documentationType: workflowState.state.documentationType,
         commitMessage: args.commitMessage,
+        releaseCommand: workflowState.state.releaseCommand,
+        releaseNotes: workflowState.state.releaseNotes,
       });
 
       const completedTask = workflowState.state.taskDescription;
@@ -518,14 +1267,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         coding: "🔨 Currently coding",
         testing: "🧪 Ready for testing",
         documentation: "📝 Ready for documentation",
-        ready: "✅ Ready to commit",
+        ready: "✅ Ready for verification",
+        commit: "📦 Ready to commit & push",
+        release: "🚀 Ready to release",
+        ready_to_complete: "✅ Release completed",
       };
 
       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.testsPassed ? "✅" : "⏳"} Tests passed\n${status.documentationCreated ? "✅" : "⏳"} Documentation created\n${status.readyToCommit ? "✅" : "⏳"} Ready to commit\n\nNext: ${getNextStep(status)}`,
+            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)}`,
           },
         ],
       };
@@ -582,10 +1334,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Helper function
 export function getNextStep(status) {
   if (!status.bugFixed) return "Mark feature/bug as fixed";
-  if (!status.testsPassed) return "Create and run tests";
+  if (!status.testsCreated) return "Create tests";
+  if (!status.testsPassed) return "Run tests";
   if (!status.documentationCreated) return "Create documentation";
-  if (!status.readyToCommit) return "Check if ready to commit";
-  return "Commit and push!";
+  if (!status.readyCheckCompleted) return "Run 'check_ready_to_commit'";
+  if (!status.commitAndPushCompleted) return "Run 'commit_and_push'";
+  if (!status.released) return "Run 'perform_release'";
+  return "Complete the task";
 }
 
 // Define prompts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.0.2",
+  "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-"));
@@ -23,6 +30,14 @@ test("WorkflowState persists data across save/load", async () => {
     state.state.currentPhase = "testing";
     state.state.taskDescription = "Test persistence";
     state.state.bugFixed = true;
+    state.state.testsCreated = true;
+    state.state.readyCheckCompleted = true;
+    state.state.released = true;
+    state.state.releaseCommand = "npm run release";
+    state.state.releaseNotes = "Automated release";
+    state.state.commitAndPushCompleted = true;
+    state.state.lastCommitMessage = "test: persistence";
+    state.state.lastPushBranch = "main";
     await state.save();
 
     const reloaded = new WorkflowState(state.stateFile);
@@ -31,21 +46,37 @@ test("WorkflowState persists data across save/load", async () => {
     assert.equal(reloaded.state.currentPhase, "testing");
     assert.equal(reloaded.state.taskDescription, "Test persistence");
     assert.equal(reloaded.state.bugFixed, true);
+    assert.equal(reloaded.state.testsCreated, true);
+    assert.equal(reloaded.state.readyCheckCompleted, true);
+    assert.equal(reloaded.state.released, true);
+    assert.equal(reloaded.state.releaseCommand, "npm run release");
+    assert.equal(reloaded.state.releaseNotes, "Automated release");
+    assert.equal(reloaded.state.commitAndPushCompleted, true);
+    assert.equal(reloaded.state.lastCommitMessage, "test: persistence");
+    assert.equal(reloaded.state.lastPushBranch, "main");
   });
 });
 
 test("WorkflowState reset keeps history but clears progress", async () => {
   await withWorkflowState(async (state) => {
     state.state.currentPhase = "ready";
+    state.state.testsCreated = true;
     state.state.testsPassed = true;
     state.state.documentationCreated = true;
+    state.state.readyCheckCompleted = true;
+    state.state.released = true;
+    state.state.commitAndPushCompleted = true;
     state.addToHistory({ taskDescription: "Sample task" });
 
     state.reset();
 
     assert.equal(state.state.currentPhase, "idle");
+    assert.equal(state.state.testsCreated, false);
     assert.equal(state.state.testsPassed, false);
     assert.equal(state.state.documentationCreated, false);
+    assert.equal(state.state.readyCheckCompleted, false);
+    assert.equal(state.state.released, false);
+    assert.equal(state.state.commitAndPushCompleted, false);
     assert.equal(state.state.history.length, 1);
     assert.equal(state.state.history[0].taskDescription, "Sample task");
   });
@@ -54,9 +85,12 @@ test("WorkflowState reset keeps history but clears progress", async () => {
 test("getNextStep guides workflow progression", () => {
   const baseState = {
     bugFixed: false,
+    testsCreated: false,
     testsPassed: false,
     documentationCreated: false,
-    readyToCommit: false,
+    readyCheckCompleted: false,
+    commitAndPushCompleted: false,
+    released: false,
   };
 
   assert.equal(
@@ -67,21 +101,104 @@ test("getNextStep guides workflow progression", () => {
   const afterFix = { ...baseState, bugFixed: true };
   assert.equal(
     getNextStep(afterFix),
-    "Create and run tests"
+    "Create tests"
   );
 
-  const afterTests = { ...afterFix, testsPassed: true };
+  const afterTestsCreated = { ...afterFix, testsCreated: true };
+  assert.equal(getNextStep(afterTestsCreated), "Run tests");
+
+  const afterTests = { ...afterTestsCreated, testsPassed: true };
   assert.equal(
     getNextStep(afterTests),
     "Create documentation"
   );
 
   const afterDocs = { ...afterTests, documentationCreated: true };
-  assert.equal(
-    getNextStep(afterDocs),
-    "Check if ready to commit"
-  );
+  assert.equal(getNextStep(afterDocs), "Run 'check_ready_to_commit'");
+
+  const afterReadyCheck = { ...afterDocs, readyCheckCompleted: true };
+  assert.equal(getNextStep(afterReadyCheck), "Run 'commit_and_push'");
+
+  const afterCommit = { ...afterReadyCheck, commitAndPushCompleted: true };
+  assert.equal(getNextStep(afterCommit), "Run 'perform_release'");
+
+  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);
 
-  const ready = { ...afterDocs, readyToCommit: true };
-  assert.equal(getNextStep(ready), "Commit and push!");
+  assert.equal(summary.hasChanges, true);
+  assert.deepEqual(summary.lines, ["M src/app.js", "A tests/new.test.js"]);
 });