@programinglive/dev-workflow-mcp-server 1.7.16 → 1.8.0

package/tests/handlers.test.js

@@ -147,6 +147,8 @@ test("commit_and_push commits changes and pushes", async () => {
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -215,6 +217,8 @@ test("run_full_workflow iterates until commit/release complete with clean tree",
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "chore: existing",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -272,6 +276,8 @@ test("commit_and_push uses primary branch when no branch specified", async () =>
       getCurrentBranch: async () => "feature/test",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -321,6 +327,8 @@ test("commit_and_push falls back to master when main not found", async () => {
       getCurrentBranch: async () => "feature/test",
       getPrimaryBranch: async () => "master",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -377,6 +385,8 @@ test("run_full_workflow uses provided branch for release push when commit is cle
       getCurrentBranch: async () => "feature/local",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "chore: existing",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -433,6 +443,8 @@ test("project_summary_data reads persisted file and falls back", async () => {
         getCurrentBranch: async () => "main",
         getPrimaryBranch: async () => "main",
         getLastCommitMessage: async () => "",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
         workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
       },
       utils,
@@ -467,6 +479,8 @@ test("project_summary aggregates task types and recent activity", async () => {
         getCurrentBranch: async () => "main",
         getPrimaryBranch: async () => "main",
         getLastCommitMessage: async () => "",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
         workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
       },
       utils,
@@ -510,6 +524,8 @@ test("run_full_workflow executes all steps successfully", async () => {
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => workingChanges ? "M tests/handlers.test.js\nM src/app.js" : "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () =>
         workingChanges
           ? { hasChanges: true, lines: ["M src/app.js"] }
@@ -587,6 +603,8 @@ test("run_full_workflow resumes from current phase when steps are already comple
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -652,6 +670,8 @@ test("run_full_workflow validates required arguments", async () => {
         getCurrentBranch: async () => "main",
         getPrimaryBranch: async () => "main",
         getLastCommitMessage: async () => "",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
         workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
       },
       utils,
@@ -688,6 +708,8 @@ test("force_complete_task records entry and resets state", async () => {
         getCurrentBranch: async () => "main",
         getPrimaryBranch: async () => "main",
         getLastCommitMessage: async () => "",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
         workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
       },
       utils,
@@ -727,6 +749,8 @@ test("perform_release blocks when new changes detected", async () => {
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "?? new-file.js",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
     };
 
@@ -758,6 +782,8 @@ test("continue_workflow warns when workflow is idle", async () => {
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -792,6 +818,8 @@ test("continue_workflow resets to commit when new changes detected", async () =>
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "?? new-file.js",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
     };
 
@@ -837,6 +865,8 @@ test("commit_and_push recognizes already committed work", async () => {
       getCurrentBranch: async () => "main",
       getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "fix: previous work",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -886,6 +916,8 @@ test("perform_release runs release command before pushing with tags", async () =
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
       getLastCommitMessage: async () => "",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -951,6 +983,8 @@ test("perform_release accepts shorthand patch command", async () => {
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
       getLastCommitMessage: async () => "fix: adjust labels",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -970,6 +1004,47 @@ test("perform_release accepts shorthand patch command", async () => {
   });
 });
 
+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,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "chore: docs",
+        getStatusOutput: async () => "",
+        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
+      utils,
+    });
+
+    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);
+  });
+});
+
 test("perform_release respects explicit releaseType option", async () => {
   await withWorkflowState(async (workflowState) => {
     workflowState.state.currentPhase = "release";
@@ -994,6 +1069,8 @@ test("perform_release respects explicit releaseType option", async () => {
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
       getLastCommitMessage: async () => "feat: import improvements",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 
@@ -1040,6 +1117,8 @@ test("perform_release requires commit_and_push completion when tree is clean", a
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
       getLastCommitMessage: async () => "chore: already pushed",
+      getStatusOutput: async () => "",
+      containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
 

package/tests/test-helpers.js

@@ -0,0 +1,50 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { WorkflowState } from "../workflow-state.js";
+import { shellEscape } from "../utils.js";
+import { determineReleaseTypeFromCommit, createCommitMessageParts } from "../commit-helpers.js";
+
+export 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 });
+  }
+}
+
+export const testUtils = {
+  shellEscape,
+  determineReleaseTypeFromCommit,
+  createCommitMessageParts,
+};
+
+export function createRequest(name, args) {
+  return {
+    params: {
+      name,
+      arguments: args,
+    },
+  };
+}
+
+export function createGitMock(overrides = {}) {
+  return {
+    hasWorkingChanges: async () => false,
+    hasStagedChanges: async () => false,
+    hasTestChanges: async () => true,
+    getStagedChanges: async () => [],
+    getCurrentBranch: async () => "main",
+    getPrimaryBranch: async () => "main",
+    getLastCommitMessage: async () => "",
+    getStatusOutput: async () => "",
+    containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
+    workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    ...overrides,
+  };
+}

package/tools/definitions.js

@@ -148,6 +148,21 @@ export function getToolList() {
         required: ["command"],
       },
     },
+    {
+      name: "skip_release",
+      description:
+        "Record that the release step was intentionally skipped (e.g., non-Node projects or documentation-only work). Requires a justification.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          reason: {
+            type: "string",
+            description: "Why the release step is being skipped",
+          },
+        },
+        required: ["reason"],
+      },
+    },
     {
       name: "complete_task",
       description:

package/tools/handler-modules/commit-handlers.js

@@ -0,0 +1,159 @@
+import { textResponse, isReleaseSatisfied, formatChecklist, handleReadyCheck } from "./shared.js";
+import { containsTestFilesInStatus } from "../../git-helpers.js";
+
+export async function handleCommitAndPush(args, context) {
+  const { workflowState, exec, git, utils } = context;
+  if (!workflowState.state.readyToCommit || !workflowState.state.readyCheckCompleted) {
+    const readyResponse = await handleReadyCheck(workflowState);
+    if (workflowState.state.currentPhase !== "commit") {
+      return readyResponse;
+    }
+  }
+
+  const providedCommitMessage =
+    typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
+
+  const requestedBranch = typeof args.branch === "string" ? args.branch.trim() : "";
+  const primaryBranch = await git.getPrimaryBranch();
+  const currentBranch = await git.getCurrentBranch();
+  const branchForPush = requestedBranch || primaryBranch || currentBranch || "";
+
+  const hasWorkingChanges = await git.hasWorkingChanges();
+
+  if (!hasWorkingChanges) {
+    const lastCommitMessage = await git.getLastCommitMessage();
+    const effectiveCommitMessage = lastCommitMessage || providedCommitMessage;
+
+    workflowState.state.commitAndPushCompleted = true;
+    workflowState.state.lastCommitMessage = effectiveCommitMessage || "";
+    workflowState.state.lastPushBranch = branchForPush;
+    workflowState.state.currentPhase = isReleaseSatisfied(workflowState.state) ? "ready_to_complete" : "release";
+    await workflowState.save();
+
+    return textResponse(
+      `ℹ️ No changes detected. Assuming commit and push already completed.\nLast commit: ${effectiveCommitMessage || "(unavailable)"
+      }\n\nNext: Run 'perform_release' to handle the release and push tags.`
+    );
+  }
+
+  const statusOutput = await git.getStatusOutput();
+
+  if (!workflowState.state.testsSkipped && !containsTestFilesInStatus(statusOutput)) {
+    return textResponse("⚠️ 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 textResponse(
+      `❌ Failed to stage files:\n\n${error.stderr || error.stdout || error.message}`
+    );
+  }
+
+  const stagedChanges = await git.getStagedChanges();
+  const { summary: generatedSummary, body: commitBody } = utils.createCommitMessageParts(
+    stagedChanges,
+    providedCommitMessage
+  );
+
+  if (!generatedSummary) {
+    return textResponse("⚠️ Unable to generate commit message. Please provide a 'commitMessage' manually.");
+  }
+
+  try {
+    if (commitBody) {
+      await exec(
+        `git commit -m ${utils.shellEscape(generatedSummary)} -m ${utils.shellEscape(commitBody)}`
+      );
+    } else {
+      await exec(`git commit -m ${utils.shellEscape(generatedSummary)}`);
+    }
+  } catch (error) {
+    const output = error.stderr || error.stdout || error.message || "Unknown error";
+    if (output.includes("nothing to commit")) {
+      return textResponse(
+        "⚠️ Nothing to commit. Make additional changes before running 'commit_and_push'."
+      );
+    }
+
+    return textResponse(`❌ git commit failed:\n\n${output}`);
+  }
+
+  try {
+    const pushCommand = branchForPush
+      ? `git push origin ${utils.shellEscape(branchForPush)}`
+      : "git push";
+    await exec(pushCommand);
+  } catch (error) {
+    return textResponse(
+      `❌ git push failed:\n\n${error.stderr || error.stdout || error.message}`
+    );
+  }
+
+  workflowState.state.commitAndPushCompleted = true;
+  workflowState.state.lastCommitMessage = generatedSummary;
+  workflowState.state.lastPushBranch = branchForPush;
+  workflowState.state.currentPhase = isReleaseSatisfied(workflowState.state) ? "ready_to_complete" : "release";
+  await workflowState.save();
+
+  return textResponse(
+    `✅ Commit and push completed!\n\nCommit message: ${generatedSummary}\nPushed to: ${branchForPush || "(default upstream)"
+    }\n\nNext: Run 'perform_release' to handle the release and push tags.`
+  );
+}
+
+export async function handleCompleteTask(args, workflowState) {
+  const entry = {
+    taskDescription: workflowState.state.taskDescription,
+    taskType: workflowState.state.taskType,
+    commitMessage: args.commitMessage,
+  };
+
+  workflowState.addToHistory(entry);
+  workflowState.reset();
+  await workflowState.save();
+
+  return textResponse(
+    `✅ Task completed!\n\nCommit message: ${args.commitMessage}\nHistory recorded.`
+  );
+}
+
+export async function handleForceCompleteTask(args, workflowState) {
+  const commitMessageArg =
+    typeof args.commitMessage === "string" ? args.commitMessage.trim() : "";
+  const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+
+  const commitMessage =
+    commitMessageArg || workflowState.state.lastCommitMessage || "(no commit recorded)";
+
+  workflowState.addToHistory({
+    taskDescription: workflowState.state.taskDescription,
+    taskType: workflowState.state.taskType,
+    commitMessage,
+    forced: true,
+    forceReason: reason,
+  });
+
+  workflowState.reset();
+  await workflowState.save();
+
+  const reasonText = reason ? reason : "(none provided)";
+
+  return textResponse(
+    `⚠️ Task force-completed.\n\nRecorded commit message: ${commitMessage}\nReason: ${reasonText}\nWorkflow state reset. Start a new task when ready.`
+  );
+}
+
+export async function handleDropTask(args, workflowState) {
+  workflowState.addToHistory({
+    taskDescription: workflowState.state.taskDescription,
+    taskType: workflowState.state.taskType,
+    commitMessage: workflowState.state.lastCommitMessage,
+    dropped: true,
+    dropReason: typeof args.reason === "string" ? args.reason : "",
+  });
+  workflowState.reset();
+  await workflowState.save();
+
+  return textResponse("⚠️ Task dropped. Workflow state reset.");
+}

package/tools/handler-modules/index.js

@@ -0,0 +1,222 @@
+import { textResponse, isReleaseSatisfied } from "./shared.js";
+import { handleStartTask, handleMarkBugFixed, handleCreateTests, handleSkipTests, handleRunTests, handleCreateDocumentation } from "./workflow-handlers.js";
+import { handleSkipRelease, handlePerformRelease } from "./release-handlers.js";
+import { handleCommitAndPush, handleCompleteTask, handleForceCompleteTask, handleDropTask } from "./commit-handlers.js";
+import { handleProjectSummary, handleProjectSummaryData, handleProjectSummaryDb, handleViewHistory } from "./summary-handlers.js";
+import { handleGetWorkflowStatus, handleReadyCheck, handleContinueWorkflow, handleRerunWorkflow } from "./status-handlers.js";
+
+function isErrorResponse(response) {
+  const text = response?.content?.[0]?.text || "";
+  return /^\s*[⚠️❌]/u.test(text);
+}
+
+function summarizeResponse(label, response) {
+  const text = response?.content?.[0]?.text || "";
+  const firstLine = text.split("\n")[0] || "";
+  return `${label}: ${firstLine}`;
+}
+
+async function handleRunFullWorkflow(args, { workflowState, exec, git, utils }) {
+  const description = workflowState.state.taskDescription;
+  if (!description) {
+    return textResponse("⚠️ Please start a task first using 'start_task' before running the full workflow.");
+  }
+
+  await workflowState.ensurePrimaryFile();
+
+  const requestedBranch = typeof args.branch === "string" ? args.branch.trim() : "";
+  if (requestedBranch) {
+    workflowState.state.lastPushBranch = requestedBranch;
+    await workflowState.save();
+  }
+
+  const requiredStrings = [
+    { key: "summary", message: "Provide a non-empty 'summary' for mark_bug_fixed." },
+    { key: "testCommand", message: "Provide a non-empty 'testCommand' for run_tests." },
+    { key: "documentationType", message: "Provide 'documentationType' for create_documentation." },
+    { key: "documentationSummary", message: "Provide a non-empty 'documentationSummary'." },
+    { key: "commitMessage", message: "Provide a non-empty 'commitMessage'." },
+    { key: "releaseCommand", message: "Provide a non-empty 'releaseCommand'." },
+  ];
+
+  for (const { key, message } of requiredStrings) {
+    const value = args[key];
+    if (typeof value !== "string" || value.trim() === "") {
+      return textResponse(`⚠️ ${message}`);
+    }
+  }
+
+  const steps = [];
+  const testsPassed = typeof args.testsPassed === "boolean" ? args.testsPassed : true;
+  const testDetails = typeof args.testDetails === "string" ? args.testDetails : "";
+  const releaseArgs = {
+    command: args.releaseCommand,
+  };
+  if (typeof args.releaseNotes === "string" && args.releaseNotes.trim() !== "") {
+    releaseArgs.notes = args.releaseNotes;
+  }
+  if (typeof args.releaseType === "string" && args.releaseType.trim() !== "") {
+    releaseArgs.releaseType = args.releaseType;
+  }
+  if (typeof args.preset === "string" && args.preset.trim() !== "") {
+    releaseArgs.preset = args.preset;
+  }
+
+  async function executeStep(name, handlerFn, handlerArgs = []) {
+    if (isErrorResponse(handlerFn)) {
+      return handlerFn;
+    }
+    const response = await handlerFn(...handlerArgs);
+    if (isErrorResponse(response)) {
+      return response;
+    }
+    steps.push(summarizeResponse(name, response));
+    await workflowState.load();
+    return response;
+  }
+
+  while (true) {
+    const state = workflowState.state;
+
+    if (!state.bugFixed) {
+      const resp = await executeStep("mark_bug_fixed", handleMarkBugFixed, [{ summary: args.summary }, workflowState]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!state.testsCreated) {
+      const resp = await executeStep("create_tests", handleCreateTests, [workflowState]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!state.testsPassed && !state.testsSkipped) {
+      const resp = await executeStep("run_tests", handleRunTests, [
+        { passed: testsPassed, testCommand: args.testCommand, details: testDetails },
+        workflowState,
+      ]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!state.documentationCreated) {
+      const resp = await executeStep("create_documentation", handleCreateDocumentation, [
+        { documentationType: args.documentationType, summary: args.documentationSummary },
+        workflowState,
+      ]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!state.readyCheckCompleted) {
+      const resp = await executeStep("check_ready_to_commit", handleReadyCheck, [workflowState]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!state.commitAndPushCompleted) {
+      const resp = await executeStep("commit_and_push", handleCommitAndPush, [
+        {
+          commitMessage: args.commitMessage,
+          branch: requestedBranch,
+        },
+        { workflowState, exec, git, utils },
+      ]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!isReleaseSatisfied(state)) {
+      const resp = await executeStep("perform_release", handlePerformRelease, [
+        releaseArgs,
+        { workflowState, exec, git, utils },
+      ]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    const completeResponse = await handleCompleteTask({ commitMessage: args.commitMessage }, workflowState);
+    if (isErrorResponse(completeResponse)) {
+      return completeResponse;
+    }
+    steps.push(summarizeResponse("complete_task", completeResponse));
+    break;
+  }
+
+  const summary = steps.map((line, index) => `${index + 1}. ${line}`).join("\n");
+  const celebration = workflowState.state.history?.length
+    ? "🎉 Cheers! We solved another issue and captured it in the knowledge base."
+    : "";
+  const message = [`✅ Full workflow completed successfully!`, celebration, summary].filter(Boolean).join("\n\n");
+  return textResponse(message);
+}
+
+export async function handleToolCall({
+  request,
+  normalizeRequestArgs,
+  workflowState,
+  exec,
+  git,
+  utils,
+}) {
+  try {
+    const { name } = request.params;
+    const { args, error: argumentsError } = normalizeRequestArgs(request.params.arguments);
+
+    if (argumentsError) {
+      return textResponse(argumentsError);
+    }
+
+    switch (name) {
+      case "start_task":
+        return handleStartTask(args, workflowState);
+      case "mark_bug_fixed":
+        return handleMarkBugFixed(args, workflowState);
+      case "create_tests":
+        return handleCreateTests(workflowState);
+      case "skip_tests":
+        return handleSkipTests(args, workflowState);
+      case "run_tests":
+        return handleRunTests(args, workflowState);
+      case "create_documentation":
+        return handleCreateDocumentation(args, workflowState);
+      case "check_ready_to_commit":
+        return handleReadyCheck(workflowState);
+      case "commit_and_push":
+        return handleCommitAndPush(args, { workflowState, exec, git, utils });
+      case "perform_release":
+        return handlePerformRelease(args, { workflowState, exec, git, utils });
+      case "skip_release":
+        return handleSkipRelease(args, workflowState);
+      case "complete_task":
+        return handleCompleteTask(args, workflowState);
+      case "force_complete_task":
+        return handleForceCompleteTask(args, workflowState);
+      case "drop_task":
+        return handleDropTask(args, workflowState);
+      case "get_workflow_status":
+        return handleGetWorkflowStatus(workflowState);
+      case "view_history":
+        return handleViewHistory(args, workflowState);
+      case "project_summary":
+        return handleProjectSummary(workflowState);
+      case "project_summary_data":
+        return handleProjectSummaryData(workflowState);
+      case "project_summary_db":
+        return handleProjectSummaryDb(workflowState);
+      case "continue_workflow":
+        return handleContinueWorkflow(workflowState, { workflowState, exec, git, utils });
+      case "rerun_workflow":
+        return handleRerunWorkflow(workflowState);
+      case "run_full_workflow":
+        return handleRunFullWorkflow(args, { workflowState, exec, git, utils });
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    console.error("Tool handler error:", error);
+    return textResponse(
+      "⚠️ Internal server error while processing the tool request. Please try again."
+    );
+  }
+}