@programinglive/dev-workflow-mcp-server 1.7.17 → 1.8.1

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.8.1](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.8.0...v1.8.1) (2025-12-26)
+
+
+### 📝 Documentation
+
+* add release notes for v1.8.0 ([5a4025b](https://github.com/programinglive/dev-workflow-mcp-server/commit/5a4025b8cc6bbd4aa389c7435d585ee15cd3416b))
+* refresh PRD and README for v1.8.0 ([d7ff89e](https://github.com/programinglive/dev-workflow-mcp-server/commit/d7ff89eaf2c8bf89e52110f91b8b84fa26a9ceed))
+
+## [1.8.0](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.7.17...v1.8.0) (2025-12-26)
+
+
+### ♻️ Refactors
+
+* complete handlers.js modularization and fix all tests ([af5b3d6](https://github.com/programinglive/dev-workflow-mcp-server/commit/af5b3d60db025611e9a84a27ccc78f5999d0ead7))
+* split handlers.test.js into smaller focused test modules ([321bbe5](https://github.com/programinglive/dev-workflow-mcp-server/commit/321bbe50d34348202f9e096e5b1903cae519dac6))
+
 ### [1.7.17](https://github.com/programinglive/dev-workflow-mcp-server/compare/v1.7.16...v1.7.17) (2025-12-26)
 
 

package/README.md

@@ -25,6 +25,14 @@ This MCP server guides you through a disciplined development workflow:
 6. **Commit & Push** - Let the server stage, commit, **and push** your changes once verification passes (if you make new edits afterward, the workflow moves back to this step automatically)
 7. **Release** - After the push succeeds, record the release details before closing out the task
 
+## 🆕 What's New in v1.8.0
+
+- **Modular Handler Architecture** – `tools/handlers.js` now re-exports focused handler modules, improving maintainability and bundler behavior.
+- **Organized Test Suite** – The 1k-line `tests/handlers.test.js` has been split into `handlers-*.test.js` files with shared helpers, reducing duplication and clarifying intent.
+- **Shared Test Utilities** – New `tests/test-helpers.js` centralizes workflow state setup, request builders, and git mocks.
+- **Documentation Refresh** – PRD moved to `docs/PRD.md` root, status bumped to v1.8.0, and release notes updated to reflect the current workflow.
+- **Release Hygiene** – Recommended flow now includes `npm run release:<type>` followed by `git push --follow-tags origin main` to keep stages clean.
+
 ## 🚀 Installation
 
 ### Option 1: Install as Dependency in Your Project (Recommended)

package/docs/{product/PRD.md → PRD.md}

@@ -3,8 +3,8 @@
 ## 1. Overview
 - **Product**: Development Workflow MCP Server
 - **Prepared by**: Cascade (AI assistant)
-- **Date**: 2025-12-16
-- **Status**: Live v1.7.15
+- **Date**: 2025-12-27
+- **Status**: Live v1.8.0
 
 ## 2. Problem Statement
 Developers need structured guidance to maintain disciplined workflows across projects. Existing tooling lacks enforcement of sequential best practices (testing, documentation, release hygiene) and offers limited visibility into historical task execution.
@@ -42,6 +42,9 @@ Developers need structured guidance to maintain disciplined workflows across pro
 - [x] **Multi-Database Support**: SQLite, MySQL, and PostgreSQL adapters implemented and verified.
 - [x] **Environment Configuration**: `.env` file support added.
 - [x] **Comprehensive Testing**: Automated tests for DB adapters and environment loading.
+- [x] **Modular Architecture**: Refactored handlers.js into focused handler modules for better maintainability.
+- [x] **Test Organization**: Split monolithic test file into focused test modules with shared utilities.
+- [x] **PRD Location**: Moved PRD.md to docs/ root for easier access.
 - **Multi-Database Support**: Abstract the storage layer to support:
     - SQLite (default/local)
     - MySQL

package/docs/release-notes/RELEASE_NOTES.md

@@ -4,6 +4,8 @@ Authoritative history of user-visible changes for the Development Workflow MCP S
 
 | Version | Date | Notes |
 |---------|------|-------|
+| 1.8.0 | 2025-12-27 | See CHANGELOG for details. |
+| 1.7.17 | 2025-12-26 | update release notes for v1.7.16 (0afd96b) |
 | 1.7.16 | 2025-12-24 | align database schema with dashboard and improve user ID handling (69e7f38) |
 | 1.7.15 | 2025-12-19 | optimize startup performance and add database connection resilience (bff2714) |
 | 1.7.14 | 2025-12-19 | add API dependencies and update login to use API client (94bb42f) |
@@ -44,6 +46,22 @@ Authoritative history of user-visible changes for the Development Workflow MCP S
 
 
 
+
+
+
+## 1.8.0
+
+Released on **2025-12-27**.
+
+- See CHANGELOG for details.
+
+## 1.7.17 – 📝 Documentation
+
+Released on **2025-12-26**.
+
+- update release notes for v1.7.16 (0afd96b)
+- allow skipping release step (004e4fa)
+- add @programinglive/commiter setup (1d2a19d)
 
 ## 1.7.16 – 🐛 Bug Fixes
 

package/git-helpers.js

@@ -151,6 +151,15 @@ export async function getCurrentBranch() {
   }
 }
 
+export async function getStatusOutput() {
+  try {
+    const { stdout } = await exec("git status --porcelain");
+    return stdout;
+  } catch (error) {
+    return "";
+  }
+}
+
 export async function getPrimaryBranch() {
   try {
     // Check if 'main' exists on origin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.7.17",
+  "version": "1.8.1",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",

package/tests/handlers-commit.test.js

@@ -0,0 +1,174 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleToolCall } from "../tools/handlers.js";
+import { withWorkflowState, testUtils, createRequest, createGitMock } from "./test-helpers.js";
+
+test("commit_and_push commits changes and pushes", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock({
+        hasWorkingChanges: async () => true,
+        getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
+        getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+      }),
+      utils: testUtils,
+    });
+
+    const pushCommand = commands.find((command) => command.startsWith("git push"));
+    assert.ok(pushCommand, "git push should be executed during commit");
+    assert.ok(
+      pushCommand.startsWith("git push origin"),
+      "push command should target origin"
+    );
+    assert.equal(
+      commands.some((command) => command.startsWith("git commit")),
+      true,
+      "git commit should be executed"
+    );
+    assert.ok(
+      response.content[0].text.includes("Commit and push completed!"),
+      "response should confirm commit and push"
+    );
+    assert.equal(workflowState.state.commitAndPushCompleted, true);
+    assert.equal(workflowState.state.lastCommitMessage.length > 0, true);
+    assert.equal(workflowState.state.currentPhase, "release");
+  });
+});
+
+test("commit_and_push uses primary branch when no branch specified", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "feat: test" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock({
+        hasWorkingChanges: async () => true,
+        getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
+        getCurrentBranch: async () => "feature/test",
+        getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+      }),
+      utils: testUtils,
+    });
+
+    const pushCommand = commands.find((command) => command.startsWith("git push"));
+    assert.ok(pushCommand, "git push should be executed");
+    assert.ok(
+      /origin\s+['"]?main['"]?/.test(pushCommand),
+      "push should use primary branch (main) when no branch specified"
+    );
+  });
+});
+
+test("commit_and_push falls back to master when main not found", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "feat: test" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock({
+        hasWorkingChanges: async () => true,
+        getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
+        getPrimaryBranch: async () => "master",
+        getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+      }),
+      utils: testUtils,
+    });
+
+    const pushCommand = commands.find((command) => command.startsWith("git push"));
+    assert.ok(pushCommand, "git push should be executed");
+    assert.ok(
+      /origin\s+['"]?master['"]?/.test(pushCommand),
+      "push should use master when main not found"
+    );
+  });
+});
+
+test("commit_and_push recognizes already committed work", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock({
+        hasWorkingChanges: async () => false,
+        getLastCommitMessage: async () => "fix: previous work",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+      }),
+      utils: testUtils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("No changes detected"),
+      "response should indicate no changes"
+    );
+    assert.equal(workflowState.state.commitAndPushCompleted, true);
+    assert.equal(workflowState.state.currentPhase, "release");
+  });
+});

package/tests/handlers-release.test.js

@@ -0,0 +1,212 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleToolCall } from "../tools/handlers.js";
+import { withWorkflowState, testUtils, createRequest, createGitMock } from "./test-helpers.js";
+
+test("perform_release runs release command before pushing with tags", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.lastPushBranch = "feature/split";
+    workflowState.state.lastCommitMessage = "fix: address issue";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("perform_release", { command: "npm run release" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock(),
+      utils: testUtils,
+    });
+
+    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
+    assert.ok(releaseCommand, "release command should run");
+    assert.ok(
+      commands.some((command) => command.startsWith("git push --follow-tags")),
+      "release should push tags"
+    );
+  });
+});
+
+test("perform_release accepts shorthand patch command", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.lastCommitMessage = "fix: adjust labels";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+      return { stdout: "" };
+    };
+
+    await handleToolCall({
+      request: createRequest("perform_release", { command: "patch" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock(),
+      utils: testUtils,
+    });
+
+    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
+    assert.ok(releaseCommand, "release command should run with patch");
+  });
+});
+
+test("perform_release respects explicit releaseType option", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+      return { stdout: "" };
+    };
+
+    await handleToolCall({
+      request: createRequest("perform_release", {
+        command: "npm run release",
+        releaseType: "minor",
+      }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock(),
+      utils: testUtils,
+    });
+
+    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
+    assert.ok(releaseCommand, "release command should run");
+    assert.ok(
+      releaseCommand.includes("-- --release-as minor"),
+      "release command should append provided releaseType"
+    );
+  });
+});
+
+test("perform_release blocks when new changes detected", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "?? new-file.js" };
+      }
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("perform_release", { command: "patch" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock({
+        hasWorkingChanges: async () => true,
+        getStatusOutput: async () => "?? new-file.js",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+        workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
+      }),
+      utils: testUtils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("run 'commit_and_push' again"),
+      "response should instruct to recommit"
+    );
+    assert.equal(workflowState.state.currentPhase, "commit");
+    assert.equal(workflowState.state.commitAndPushCompleted, false);
+  });
+});
+
+test("perform_release requires commit_and_push completion when tree is clean", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = false;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.lastPushBranch = "";
+    workflowState.state.lastCommitMessage = "";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("perform_release", { command: "npm run release" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: execStub,
+      git: createGitMock({
+        getLastCommitMessage: async () => "chore: already pushed",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+      }),
+      utils: testUtils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("commit_and_push"),
+      "response should mention commit_and_push requirement"
+    );
+  });
+});
+
+test("skip_release records justification and advances to completion phase", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.currentPhase = "release";
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.lastCommitMessage = "chore: docs";
+    workflowState.state.releaseSkipped = false;
+    workflowState.state.released = false;
+    workflowState.state.releaseCommand = "";
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("skip_release", { reason: "Python project – no npm release" }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: createGitMock(),
+      utils: testUtils,
+    });
+
+    const text = response.content[0].text;
+    assert.ok(text.includes("Release step skipped"), "response should mention release was skipped");
+    assert.equal(workflowState.state.releaseSkipped, true);
+    assert.equal(workflowState.state.releaseSkippedReason, "Python project – no npm release");
+    assert.equal(workflowState.state.releaseCommand, "(skipped)");
+    assert.equal(workflowState.state.currentPhase, "ready_to_complete");
+    assert.equal(workflowState.state.released, false);
+  });
+});

package/tests/handlers-workflow.test.js

@@ -0,0 +1,68 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleToolCall } from "../tools/handlers.js";
+import { withWorkflowState, testUtils, createRequest, createGitMock } from "./test-helpers.js";
+
+test("run_tests guidance mentions core documentation types", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.bugFixed = true;
+    workflowState.state.testsCreated = true;
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("run_tests", {
+        passed: true,
+        testCommand: "npm test",
+      }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: createGitMock(),
+      utils: testUtils,
+    });
+
+    const text = response.content[0].text;
+    assert.ok(
+      text.includes("create or update documentation using 'create_documentation'"),
+      "run_tests guidance should mention create or update documentation",
+    );
+    assert.ok(
+      text.includes('"PRD", "README", "RELEASE_NOTES"'),
+      "run_tests guidance should list core documentation types",
+    );
+  });
+});
+
+test("create_documentation verifies PRD file exists", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.testsPassed = true;
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("create_documentation", {
+        documentationType: "PRD",
+        summary: "Updated PRD for documentation workflow expectations",
+      }),
+      normalizeRequestArgs: (args) => ({ args, error: null }),
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: createGitMock(),
+      utils: testUtils,
+    });
+
+    assert.equal(workflowState.state.documentationCreated, true);
+    assert.equal(workflowState.state.documentationType, "PRD");
+    assert.equal(
+      workflowState.state.documentationSummary,
+      "Updated PRD for documentation workflow expectations",
+    );
+    assert.ok(
+      response.content[0].text.includes("Documentation created/updated!"),
+      "create_documentation response should mention created/updated",
+    );
+    assert.ok(
+      response.content[0].text.includes("PRD verified"),
+      "create_documentation response should verify PRD file",
+    );
+  });
+});