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

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

@@ -0,0 +1,193 @@
+import { textResponse, isReleaseSatisfied, resetToCommitIfWorkingChanges, summarizeHistory } from "./shared.js";
+
+export async function handleSkipRelease(args, workflowState) {
+  if (workflowState.state.currentPhase === "idle") {
+    return textResponse("⚠️ Please start a task first using 'start_task' before skipping release.");
+  }
+
+  const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+  if (!reason) {
+    return textResponse("⚠️ Provide a non-empty 'reason' explaining why the release step is being skipped.");
+  }
+
+  if (workflowState.state.releaseSkipped) {
+    workflowState.state.releaseSkippedReason = reason;
+    await workflowState.save();
+    return textResponse(
+      `ℹ️ Release step was already skipped for this task.\nUpdated reason: ${reason}\n\nNext: run 'complete_task' to wrap up.`
+    );
+  }
+
+  if (workflowState.state.released) {
+    return textResponse("⚠️ A release command has already been recorded. Continue with 'complete_task'.");
+  }
+
+  if (!workflowState.state.readyCheckCompleted) {
+    return textResponse("⚠️ Please run 'check_ready_to_commit' and ensure all prerequisites pass before skipping release.");
+  }
+
+  if (!workflowState.state.commitAndPushCompleted) {
+    return textResponse("⚠️ Please complete 'commit_and_push' before skipping release.");
+  }
+
+  workflowState.state.releaseSkipped = true;
+  workflowState.state.releaseSkippedReason = reason;
+  workflowState.state.released = false;
+  workflowState.state.releaseCommand = "(skipped)";
+  workflowState.state.releaseNotes = "";
+  workflowState.state.currentPhase = "ready_to_complete";
+  await workflowState.save();
+
+  return textResponse(
+    `⚠️ Release step skipped.\nReason: ${reason}\n\n✅ Next: run 'complete_task' with your final commit message to close out the workflow.`
+  );
+}
+
+export async function handlePerformRelease(args, context) {
+  const { workflowState, exec, git, utils } = context;
+
+  if (workflowState.state.currentPhase === "idle") {
+    return textResponse("⚠️ Please start a task first using 'start_task'!");
+  }
+
+  if (await resetToCommitIfWorkingChanges(workflowState, git)) {
+    return textResponse(
+      "⚠️ Detected new changes after the last commit. Please run 'commit_and_push' again before recording a release."
+    );
+  }
+
+  if (!workflowState.state.readyCheckCompleted) {
+    return textResponse(
+      "⚠️ Please run 'check_ready_to_commit' and ensure all checks pass before releasing!"
+    );
+  }
+
+  if (!workflowState.state.commitAndPushCompleted) {
+    const hasWorkingChanges = await git.hasWorkingChanges();
+
+    if (hasWorkingChanges) {
+      return textResponse(
+        "⚠️ Please run 'commit_and_push' after the ready check before recording a release!"
+      );
+    }
+
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    return textResponse(
+      "⚠️ Please run 'commit_and_push' after the ready check before recording a release!"
+    );
+  }
+
+  const rawReleaseCommand = typeof args.command === "string" ? args.command.trim() : "";
+  const releaseTypeArg =
+    typeof args.releaseType === "string" ? args.releaseType.trim().toLowerCase() : "";
+  const presetArg = typeof args.preset === "string" ? args.preset.trim().toLowerCase() : "";
+  const recognizedTypes = new Set(["major", "minor", "patch"]);
+
+  const tokens = rawReleaseCommand
+    .toLowerCase()
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+
+  let releaseType = "";
+  if (recognizedTypes.has(releaseTypeArg)) {
+    releaseType = releaseTypeArg;
+  } else if (recognizedTypes.has(presetArg)) {
+    releaseType = presetArg;
+  } else if (tokens.length > 0) {
+    const possibleType = tokens[tokens.length - 1];
+    if (recognizedTypes.has(possibleType)) {
+      releaseType = possibleType;
+    }
+  }
+
+  let releaseCommand = rawReleaseCommand;
+  if (releaseCommand && recognizedTypes.has(releaseCommand.toLowerCase())) {
+    releaseType = releaseCommand.toLowerCase();
+    releaseCommand = "";
+  }
+
+  const scriptTypeMatch = /release:(major|minor|patch)/i.exec(releaseCommand);
+  if (scriptTypeMatch) {
+    releaseType = scriptTypeMatch[1].toLowerCase();
+  }
+
+  if (!releaseCommand && releaseType) {
+    releaseCommand = `npm run release:${releaseType}`;
+  }
+
+  if (!releaseCommand) {
+    return textResponse("⚠️ Please provide a non-empty 'command' when using 'perform_release'.");
+  }
+
+  let statusOutput;
+  try {
+    const { stdout } = await exec("git status --porcelain");
+    statusOutput = stdout;
+  } catch (error) {
+    const details = error.stderr || error.stdout || error.message || "Unknown error";
+    return textResponse(
+      `⚠️ Unable to verify Git status. Refusing to run the release command until the repository state can be checked.\n\nDetails:\n${details}`
+    );
+  }
+
+  const statusSummary = git.workingTreeSummary(statusOutput);
+  if (statusSummary.hasChanges) {
+    const changeDetails =
+      statusSummary.lines.length > 0
+        ? statusSummary.lines.map((line) => `• ${line}`).join("\n")
+        : "• (unable to list changes)";
+
+    return textResponse(
+      `⚠️ Working tree not clean! Please commit or stash all changes before running 'perform_release'.\n\nDetected changes:\n${changeDetails}`
+    );
+  }
+
+  const lastCommitMessage = await git.getLastCommitMessage();
+  if (!releaseType) {
+    releaseType = utils.determineReleaseTypeFromCommit(
+      lastCommitMessage || workflowState.state.lastCommitMessage
+    );
+  }
+
+  const finalCommand =
+    releaseCommand.includes("--release-as") || /release:(major|minor|patch)/i.test(releaseCommand)
+      ? releaseCommand
+      : `${releaseCommand} -- --release-as ${releaseType}`;
+
+  try {
+    await exec(finalCommand);
+  } catch (error) {
+    return textResponse(
+      `❌ Release command failed:\n\n${error.stderr || error.stdout || error.message}`
+    );
+  }
+
+  const branchForPush = workflowState.state.lastPushBranch || (await git.getCurrentBranch()) || "";
+  const pushCommand = branchForPush
+    ? `git push --follow-tags origin ${utils.shellEscape(branchForPush)}`
+    : "git push --follow-tags";
+
+  try {
+    await exec(pushCommand);
+  } catch (error) {
+    return textResponse(
+      `❌ git push (with tags) 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();
+
+  const message = summarizeHistory(workflowState.state.history, args.limit || 10);
+  if (!message) {
+    return textResponse("📜 No workflow history yet.");
+  }
+
+  return textResponse(message);
+}

package/tools/handler-modules/shared.js

@@ -0,0 +1,187 @@
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+export const PROJECT_SUMMARY_FILENAME = "project-summary.json";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const textResponse = (text) => ({
+  content: [
+    {
+      type: "text",
+      text,
+    },
+  ],
+});
+
+export function isReleaseSatisfied(state) {
+  return Boolean(state?.released || state?.releaseSkipped);
+}
+
+export async function resetToCommitIfWorkingChanges(workflowState, git) {
+  if (!workflowState.state.commitAndPushCompleted) {
+    return false;
+  }
+
+  const hasWorkingChanges = await git.hasWorkingChanges();
+  const hasStagedChanges = await git.hasStagedChanges();
+
+  if (!hasWorkingChanges && !hasStagedChanges) {
+    return false;
+  }
+
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.releaseSkipped = false;
+  workflowState.state.releaseSkippedReason = "";
+  workflowState.state.currentPhase = "commit";
+  workflowState.state.releaseCommand = "";
+  workflowState.state.releaseNotes = "";
+  await workflowState.save();
+  return true;
+}
+
+export function formatChecklist(checks) {
+  return checks.map((c) => `${c.done ? "✅" : "❌"} ${c.name}`).join("\n");
+}
+
+export function summarizeHistory(history, limit) {
+  const recent = history.slice(-limit).reverse();
+  if (recent.length === 0) {
+    return null;
+  }
+
+  const historyText = recent
+    .map(
+      (entry, index) =>
+        `${index + 1}. [${new Date(entry.timestamp).toLocaleString()}]\n   Task: ${entry.taskDescription}\n   Type: ${entry.taskType}\n   Commit: ${entry.commitMessage}\n`
+    )
+    .join("\n");
+
+  return `📜 Workflow History (last ${recent.length} tasks)\n\n${historyText}`;
+}
+
+export function generateProjectSummary(history) {
+  if (!history || history.length === 0) {
+    return "No workflow history available.";
+  }
+
+  const taskTypes = {};
+  const recentTasks = history.slice(-20);
+
+  for (const entry of recentTasks) {
+    const type = entry.taskType || "other";
+    taskTypes[type] = (taskTypes[type] || 0) + 1;
+  }
+
+  const typeSummary = Object.entries(taskTypes)
+    .map(([type, count]) => `${type}: ${count}`)
+    .join(", ");
+
+  const totalTasks = history.length;
+  const lastTask = history[history.length - 1];
+  const lastActive = lastTask ? new Date(lastTask.timestamp).toLocaleDateString() : "Never";
+
+  return `🧠 Project Knowledge Summary\n\n📊 Stats\n- Total tasks completed: ${totalTasks}\n- Recent task mix: ${typeSummary}\n- Last active: ${lastActive}\n\n📝 Recent tasks (last 5)\n${history.slice(-5).reverse().map((e, i) => `${i + 1}. ${e.taskDescription} (${e.taskType})`).join("\n")}`;
+}
+
+export function getContinueGuidance(status) {
+  switch (status.currentPhase) {
+    case "coding": {
+      const task = status.taskDescription ? ` "${status.taskDescription}"` : "";
+      return `Finish implementing${task} and then run 'mark_bug_fixed' with a brief summary of the change.`;
+    }
+    case "testing":
+      if (!status.testsCreated) {
+        return "Create automated coverage now using 'create_tests' before recording any results.";
+      }
+
+      if (status.testsPassed) {
+        return "With tests green, move on to 'create_documentation' and capture what changed.";
+      }
+
+      if (status.testsSkipped) {
+        return "Document why tests were skipped using 'create_documentation' so the workflow can proceed.";
+      }
+
+      return status.testCommand
+        ? `Fix any failing tests and re-run '${status.testCommand}'. Once they pass, record the results with 'run_tests'.`
+        : "Run your automated tests and record the outcome with 'run_tests'. Fix any failures before moving forward.";
+    case "documentation":
+      return status.testsSkipped
+        ? `Document the change (including manual QA for skipped tests) with 'create_documentation'. Reason recorded: ${status.testsSkippedReason || "(none provided)"}.`
+        : "Capture your updates with 'create_documentation' (provide the documentation type and a short summary).";
+    case "ready":
+      return "Run 'check_ready_to_commit' to verify all prerequisite steps before committing.";
+    case "commit":
+      return "All checks passed—run 'commit_and_push' with your commit message (and optional branch).";
+    case "release":
+      return "Commit recorded. Execute 'perform_release' with the release command you ran to publish changes, or call 'skip_release' with a justification if no release is required.";
+    case "ready_to_complete":
+      return "Release recorded. Finish up by calling 'complete_task' with the commit message you used.";
+    default:
+      return "Review your workflow progress and complete the next required step.";
+  }
+}
+
+export async function handleReadyCheck(workflowState) {
+  const status = workflowState.state;
+  const testsCreatedDone = status.testsSkipped || status.testsCreated;
+  const testsPassedDone = status.testsSkipped || status.testsPassed;
+  const checks = [
+    { name: "Task started", done: status.currentPhase !== "idle" },
+    { name: "Feature/bug fixed", done: status.bugFixed },
+    {
+      name: status.testsSkipped ? "Tests skipped (manual QA documented)" : "Tests created",
+      done: testsCreatedDone,
+    },
+    {
+      name: status.testsSkipped ? "Tests skipped acknowledged" : "Tests passed",
+      done: testsPassedDone,
+    },
+    { name: "Documentation created", done: status.documentationCreated },
+  ];
+
+  const allDone = checks.every((c) => c.done);
+  const checkList = formatChecklist(checks);
+
+  workflowState.state.readyCheckCompleted = allDone;
+  if (allDone) {
+    if (workflowState.state.commitAndPushCompleted) {
+      workflowState.state.currentPhase = isReleaseSatisfied(workflowState.state) ? "ready_to_complete" : "release";
+    } else {
+      workflowState.state.currentPhase = "commit";
+    }
+  }
+  await workflowState.save();
+
+  if (allDone) {
+    return textResponse(
+      `🎉 ALL CHECKS PASSED!\n\n${checkList}\n\n✅ Next actions:\n1. Run 'commit_and_push' (commits and pushes your changes)\n2. Run 'perform_release' (handles versioning, tags, and final push)\n3. Finish with 'complete_task'\n\nTip: Provide the optional 'branch' argument to 'commit_and_push' to push to a non-default branch.\n\nTask: ${status.taskDescription}`
+    );
+  }
+
+  return textResponse(`⚠️ NOT READY TO COMMIT!\n\n${checkList}\n\nPlease complete all steps before committing.`);
+}
+
+export async function loadProjectSummary(workflowState) {
+  const summaryPath = path.join(path.dirname(workflowState.stateFile), PROJECT_SUMMARY_FILENAME);
+  try {
+    const data = await fs.readFile(summaryPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export const prdPath = path.join(__dirname, "..", "docs", "product", "PRD.md");
+
+export function ensurePrdExists() {
+  return existsSync(prdPath);
+}

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

@@ -0,0 +1,134 @@
+import { textResponse, formatChecklist, isReleaseSatisfied, getContinueGuidance, resetToCommitIfWorkingChanges } from "./shared.js";
+import { handleCommitAndPush } from "./commit-handlers.js";
+
+export function handleGetWorkflowStatus(workflowState) {
+  const status = workflowState.state;
+  const nextStep = status ? status.currentPhase : "idle";
+
+  return textResponse(
+    `📊 Current Workflow Status:
+
+Phase: ${status.currentPhase}
+Task: ${status.taskDescription || "(none)"}
+Bug fixed: ${status.bugFixed ? "✅" : "❌"}
+Tests created: ${status.testsCreated ? "✅" : "❌"}
+Tests passed: ${status.testsPassed ? "✅" : "❌"}
+Documentation: ${status.documentationCreated ? "✅" : "❌"}
+Ready check: ${status.readyCheckCompleted ? "✅" : "❌"}
+Commit & push: ${status.commitAndPushCompleted ? "✅" : "❌"}
+Released: ${status.released ? "✅" : "❌"}
+
+Next step: ${nextStep}`
+  );
+}
+
+export async function handleReadyCheck(workflowState) {
+  const status = workflowState.state;
+  const testsCreatedDone = status.testsSkipped || status.testsCreated;
+  const testsPassedDone = status.testsSkipped || status.testsPassed;
+  const checks = [
+    { name: "Task started", done: status.currentPhase !== "idle" },
+    { name: "Feature/bug fixed", done: status.bugFixed },
+    {
+      name: status.testsSkipped ? "Tests skipped (manual QA documented)" : "Tests created",
+      done: testsCreatedDone,
+    },
+    {
+      name: status.testsSkipped ? "Tests skipped acknowledged" : "Tests passed",
+      done: testsPassedDone,
+    },
+    { name: "Documentation created", done: status.documentationCreated },
+  ];
+
+  const allDone = checks.every((c) => c.done);
+  const checkList = formatChecklist(checks);
+
+  workflowState.state.readyCheckCompleted = allDone;
+  if (allDone) {
+    if (workflowState.state.commitAndPushCompleted) {
+      workflowState.state.currentPhase = isReleaseSatisfied(workflowState.state) ? "ready_to_complete" : "release";
+    } else {
+      workflowState.state.currentPhase = "commit";
+    }
+  }
+  await workflowState.save();
+
+  if (allDone) {
+    return textResponse(
+      `🎉 ALL CHECKS PASSED!\n\n${checkList}\n\n✅ Next actions:\n1. Run 'commit_and_push' (commits and pushes your changes)\n2. Run 'perform_release' (handles versioning, tags, and final push)\n3. Finish with 'complete_task'\n\nTip: Provide the optional 'branch' argument to 'commit_and_push' to push to a non-default branch.\n\nTask: ${status.taskDescription}`
+    );
+  }
+
+  return textResponse(`⚠️ NOT READY TO COMMIT!\n\n${checkList}\n\nPlease complete all steps before committing.`);
+}
+
+export async function handleContinueWorkflow(workflowState, context) {
+  const status = workflowState.state;
+
+  if (!status || status.currentPhase === "idle") {
+    return textResponse("⚠️ No active workflow. Use 'start_task' to kick off a new task before continuing.");
+  }
+
+  if (await resetToCommitIfWorkingChanges(workflowState, context.git)) {
+    return textResponse(
+      "⚠️ Detected new changes after the last commit. Workflow moved back to the commit phase. Run 'commit_and_push' to capture the latest updates before continuing."
+    );
+  }
+
+  if (status.currentPhase === "ready") {
+    return handleReadyCheck(workflowState);
+  }
+
+  if (status.currentPhase === "commit") {
+    return handleCommitAndPush({}, context);
+  }
+
+  if (status.currentPhase === "release") {
+    return textResponse(
+      "⚠️ Release phase requires explicit command. Run 'perform_release' with your release command (e.g., 'npm run release')."
+    );
+  }
+
+  const sections = [
+    `📊 Current Phase: ${status.currentPhase}`,
+    `📝 Task: ${status.taskDescription || "(none)"}`,
+  ];
+
+  if (status.testsSkipped) {
+    sections.push(`⚠️ Tests skipped: ${status.testsSkippedReason || "(no reason provided)"}`);
+  }
+
+  if (
+    status.currentPhase === "testing" &&
+    status.testsCreated &&
+    !status.testsPassed &&
+    typeof status.testCommand === "string" &&
+    status.testCommand.trim() !== ""
+  ) {
+    sections.push(`🧪 Last test command: ${status.testCommand}`);
+  }
+
+  sections.push(`➡️ ${getContinueGuidance(status)}`);
+
+  return textResponse(sections.join("\n\n"));
+}
+
+export async function handleRerunWorkflow(workflowState) {
+  const currentDescription = workflowState.state.taskDescription;
+  const currentType = workflowState.state.taskType;
+
+  if (!currentDescription) {
+    return textResponse("⚠️ No active task to rerun. Use 'start_task' to begin a new workflow.");
+  }
+
+  workflowState.reset();
+
+  workflowState.state.currentPhase = "coding";
+  workflowState.state.taskDescription = currentDescription;
+  workflowState.state.taskType = currentType;
+  await workflowState.save();
+
+  return textResponse(
+    `🔄 Rerunning workflow from the start!\n\nTask: ${currentDescription}\nType: ${currentType}\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. ⏳ Run 'commit_and_push' (commits and pushes)\n8. ⏳ Run 'perform_release' (handles versioning and tags)\n9. ⏳ Complete task\n\n🎯 Be conscious about what you're coding!`
+  );
+}

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

@@ -0,0 +1,46 @@
+import fs from "fs/promises";
+import path from "path";
+import { textResponse, generateProjectSummary, summarizeHistory, PROJECT_SUMMARY_FILENAME } from "./shared.js";
+
+export function handleProjectSummary(workflowState) {
+  const summary = generateProjectSummary(workflowState.state.history);
+  return textResponse(summary);
+}
+
+export async function handleProjectSummaryData(workflowState) {
+  const summaryPath = path.join(path.dirname(workflowState.stateFile), PROJECT_SUMMARY_FILENAME);
+  try {
+    const data = await fs.readFile(summaryPath, "utf-8");
+    const parsed = JSON.parse(data);
+    const formatted = `🧠 Project Knowledge Summary (from persisted data)\n\n📊 Stats\n- Total tasks completed: ${parsed.totalTasks}\n- Recent task mix: ${Object.entries(parsed.taskTypes).map(([t, c]) => `${t}: ${c}`).join(", ")}\n- Last active: ${parsed.lastActive ? new Date(parsed.lastActive).toLocaleDateString() : "Never"}\n- Updated: ${new Date(parsed.updatedAt).toLocaleString()}\n\n📝 Recent tasks (last 5)\n${parsed.recentTasks.map((e, i) => `${i + 1}. ${e.description} (${e.type})`).join("\n")}`;
+    return textResponse(formatted);
+  } catch (error) {
+    return handleProjectSummary(workflowState);
+  }
+}
+
+export async function handleProjectSummaryDb(workflowState) {
+  try {
+    const { getSummaryForUser } = await import("../../db/index.js");
+    const userId = process.env.DEV_WORKFLOW_USER_ID || "default";
+    const projectPath = path.dirname(path.dirname(path.dirname(path.dirname(workflowState.stateFile))));
+
+    const summary = await getSummaryForUser(userId, projectPath);
+    if (!summary) {
+      return textResponse("📜 No project summary in database yet.");
+    }
+    const formatted = `🧠 Project Knowledge Summary (from SQLite)\n\n📊 Stats\n- Total tasks completed: ${summary.totalTasks}\n- Recent task mix: ${Object.entries(summary.taskTypes).map(([t, c]) => `${t}: ${c}`).join(", ")}\n- Last active: ${summary.lastActive ? new Date(summary.lastActive).toLocaleDateString() : "Never"}\n- Updated: ${new Date(summary.updatedAt).toLocaleString()}\n\n📝 Recent tasks (last 5)\n${summary.recentTasks.map((e, i) => `${i + 1}. ${e.description} (${e.type})`).join("\n")}`;
+    return textResponse(formatted);
+  } catch (error) {
+    return textResponse("📜 Database module not available. Use 'project_summary' or 'project_summary_data' instead.");
+  }
+}
+
+export function handleViewHistory(args, workflowState) {
+  const message = summarizeHistory(workflowState.state.history, args.limit || 10);
+  if (!message) {
+    return textResponse("📜 No workflow history yet.");
+  }
+
+  return textResponse(message);
+}