@programinglive/dev-workflow-mcp-server 1.0.9 → 1.0.11

package/package.json

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

package/tests/handlers.test.js

@@ -0,0 +1,188 @@
+import test from "node:test";
+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 } from "../workflow-state.js";
+import { handleToolCall } from "../tools/handlers.js";
+import { normalizeRequestArgs, shellEscape } from "../utils.js";
+import {
+  createCommitMessageParts,
+  determineReleaseTypeFromCommit,
+} from "../commit-helpers.js";
+
+async function withWorkflowState(callback) {
+  const tempDir = await mkdtemp(path.join(tmpdir(), "workflow-handlers-"));
+  const stateFile = path.join(tempDir, "state.json");
+  const state = new WorkflowState(stateFile);
+  await state.load();
+
+  try {
+    await callback(state);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+const utils = {
+  shellEscape,
+  determineReleaseTypeFromCommit,
+  createCommitMessageParts,
+};
+
+function createRequest(name, args) {
+  return {
+    params: {
+      name,
+      arguments: args,
+    },
+  };
+}
+
+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 git = {
+      hasWorkingChanges: async () => true,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    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("continue_workflow warns when workflow is idle", async () => {
+  await withWorkflowState(async (workflowState) => {
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasTestChanges: async () => false,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("continue_workflow", {}),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git,
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("No active workflow"),
+      "Idle workflow should prompt user to start a task"
+    );
+  });
+});
+
+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 git = {
+      hasWorkingChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("perform_release", { command: "npm run release" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
+    assert.ok(releaseCommand, "release command should be executed");
+    assert.ok(
+      releaseCommand.includes("-- --release-as patch"),
+      "release command should append release type"
+    );
+
+    const pushCommand = commands.find((command) => command.startsWith("git push"));
+    assert.ok(pushCommand, "git push with tags should be executed after release");
+    assert.ok(
+      pushCommand.startsWith("git push --follow-tags"),
+      "push command should include --follow-tags"
+    );
+    assert.ok(
+      pushCommand.includes("feature/split"),
+      "push command should target last recorded branch"
+    );
+
+    assert.equal(workflowState.state.released, true);
+    assert.equal(workflowState.state.currentPhase, "ready_to_complete");
+    assert.ok(
+      response.content[0].text.includes("No workflow history yet") ||
+        response.content[0].text.includes("Workflow History"),
+      "response should describe workflow history or absence thereof"
+    );
+  });
+});

package/tools/definitions.js

@@ -0,0 +1,211 @@
+export function getToolList() {
+  return [
+    {
+      name: "start_task",
+      description:
+        "Start a new coding task. This is the first step - be conscious about what you're coding.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          description: {
+            type: "string",
+            description: "Clear description of what you're going to code",
+          },
+          type: {
+            type: "string",
+            enum: ["feature", "bugfix", "refactor", "other"],
+            description: "Type of task",
+          },
+        },
+        required: ["description", "type"],
+      },
+    },
+    {
+      name: "mark_bug_fixed",
+      description:
+        "Mark that the bug/feature is fixed. Reminder: Now you MUST create tests!",
+      inputSchema: {
+        type: "object",
+        properties: {
+          summary: {
+            type: "string",
+            description: "Brief summary of what was fixed/implemented",
+          },
+        },
+        required: ["summary"],
+      },
+    },
+    {
+      name: "create_tests",
+      description: "Mark that tests covering the change have been created.",
+      inputSchema: {
+        type: "object",
+        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:
+        "Record test results. NEVER commit if tests fail! Only proceed if all tests are green.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          passed: {
+            type: "boolean",
+            description: "Did all tests pass?",
+          },
+          testCommand: {
+            type: "string",
+            description: "The test command that was run",
+          },
+          details: {
+            type: "string",
+            description: "Test results details",
+          },
+        },
+        required: ["passed", "testCommand"],
+      },
+    },
+    {
+      name: "create_documentation",
+      description:
+        "Mark that documentation has been created/updated. This is required before committing.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          documentationType: {
+            type: "string",
+            enum: ["README", "inline-comments", "API-docs", "changelog", "other"],
+            description: "Type of documentation created",
+          },
+          summary: {
+            type: "string",
+            description: "What was documented",
+          },
+        },
+        required: ["documentationType", "summary"],
+      },
+    },
+    {
+      name: "check_ready_to_commit",
+      description:
+        "Check if all workflow steps are completed and you're ready to commit & push.",
+      inputSchema: {
+        type: "object",
+        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:
+        "Mark the task as complete after successful commit & push. Resets workflow for next task.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          commitMessage: {
+            type: "string",
+            description: "The commit message used",
+          },
+        },
+        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.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
+    {
+      name: "view_history",
+      description: "View workflow history of completed tasks.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Number of recent tasks to show (default: 10)",
+          },
+        },
+      },
+    },
+    {
+      name: "continue_workflow",
+      description:
+        "Get guidance on the next workflow step. Automatically performs the ready check when appropriate.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
+  ];
+}