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

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/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);
+}

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

@@ -0,0 +1,219 @@
+import path from "path";
+import { existsSync } from "fs";
+import { textResponse, isReleaseSatisfied, resetToCommitIfWorkingChanges } from "./shared.js";
+
+export async function handleStartTask(args, workflowState) {
+  workflowState.reset();
+  workflowState.state.currentPhase = "coding";
+  workflowState.state.taskDescription = args.description;
+  workflowState.state.taskType = args.type;
+  workflowState.state.testsSkipped = false;
+  workflowState.state.testsSkippedReason = "";
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.lastCommitMessage = "";
+  workflowState.state.lastPushBranch = "";
+  await workflowState.save();
+
+  return textResponse(
+    `✅ 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. ⏳ Run 'commit_and_push' (commits and pushes)\n8. ⏳ Run 'perform_release' (handles versioning and tags) or 'skip_release' (when no release is needed)\n9. ⏳ Complete task\n\nReminder: Focus on writing clean, maintainable code!`
+  );
+}
+
+export async function handleMarkBugFixed(args, workflowState) {
+  if (workflowState.state.currentPhase === "idle") {
+    return textResponse("⚠️ Please start a task first using 'start_task'!");
+  }
+
+  if (workflowState.state.bugFixed) {
+    const summary = typeof args.summary === "string" ? args.summary : "";
+    if (summary && summary.trim() !== "") {
+      workflowState.state.fixSummary = summary;
+    }
+
+    if (workflowState.state.testsPassed && workflowState.state.documentationCreated) {
+      workflowState.state.currentPhase = "ready";
+      workflowState.state.readyToCommit = true;
+    } else if (workflowState.state.testsCreated) {
+      workflowState.state.currentPhase = "testing";
+    }
+    workflowState.state.readyCheckCompleted = false;
+    workflowState.state.commitAndPushCompleted = false;
+    await workflowState.save();
+
+    return textResponse(
+      "ℹ️ Already marked as fixed; kept existing tests/documentation. Continue with the next step."
+    );
+  }
+
+  workflowState.state.bugFixed = true;
+  workflowState.state.testsCreated = false;
+  workflowState.state.currentPhase = "testing";
+  workflowState.state.testsSkipped = false;
+  workflowState.state.testsSkippedReason = "";
+  workflowState.state.fixSummary = args.summary;
+  workflowState.state.readyCheckCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.releaseSkipped = false;
+  workflowState.state.releaseSkippedReason = "";
+  workflowState.state.releaseCommand = "";
+  workflowState.state.releaseNotes = "";
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.lastCommitMessage = "";
+  workflowState.state.lastPushBranch = "";
+  await workflowState.save();
+
+  return textResponse(
+    `✅ 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. ⏳ Run 'commit_and_push'\n7. ⏳ Run 'perform_release' (or 'skip_release' if no release applies)\n8. ⏳ Complete task\n\n🚫 DO NOT SKIP TESTING!`
+  );
+}
+
+export async function handleCreateTests(workflowState) {
+  if (!workflowState.state.bugFixed) {
+    return textResponse("⚠️ Please mark your feature/bug as fixed first using 'mark_bug_fixed'!");
+  }
+
+  workflowState.state.testsCreated = true;
+  workflowState.state.testsSkipped = false;
+  workflowState.state.testsSkippedReason = "";
+  workflowState.state.readyCheckCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.releaseSkipped = false;
+  workflowState.state.releaseSkippedReason = "";
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.lastCommitMessage = "";
+  workflowState.state.lastPushBranch = "";
+  await workflowState.save();
+
+  return textResponse(
+    "✅ 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. ⏳ Run 'commit_and_push'\n7. ⏳ Run 'perform_release' (or 'skip_release' if appropriate)\n8. ⏳ Complete task\n\n🧪 Run your test command and record the results using 'run_tests'."
+  );
+}
+
+export async function handleSkipTests(args, workflowState) {
+  if (workflowState.state.currentPhase === "idle") {
+    return textResponse("⚠️ No active task. Use 'start_task' before skipping tests.");
+  }
+
+  if (!workflowState.state.bugFixed) {
+    return textResponse("⚠️ Please mark your feature/bug as fixed first using 'mark_bug_fixed'!");
+  }
+
+  const reason = typeof args.reason === "string" ? args.reason.trim() : "";
+
+  if (!reason) {
+    return textResponse("⚠️ Provide a non-empty justification when skipping tests.");
+  }
+
+  workflowState.state.testsCreated = true;
+  workflowState.state.testsPassed = true;
+  workflowState.state.testsSkipped = true;
+  workflowState.state.testsSkippedReason = reason;
+  workflowState.state.currentPhase = "documentation";
+  workflowState.state.readyToCommit = false;
+  workflowState.state.readyCheckCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.releaseSkipped = false;
+  workflowState.state.releaseSkippedReason = "";
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.lastCommitMessage = "";
+  workflowState.state.lastPushBranch = "";
+  await workflowState.save();
+
+  return textResponse(
+    `⚠️ Tests skipped for this task.
+Reason: ${reason}
+
+Manual verification is now required.
+
+Next Steps:
+1. ✓ Fix/implement feature
+2. ⚠️ Tests skipped (ensure manual QA)
+3. ⏳ Create/update documentation
+4. ⏳ Run 'check_ready_to_commit'
+5. ⏳ Run 'commit_and_push'
+6. ⏳ Run 'perform_release' or 'skip_release'
+7. ⏳ Complete task`
+  );
+}
+
+export async function handleRunTests(args, workflowState) {
+  if (!workflowState.state.bugFixed) {
+    return textResponse("⚠️ Please mark your feature/bug as fixed first using 'mark_bug_fixed'!");
+  }
+
+  if (!workflowState.state.testsCreated) {
+    return textResponse("⚠️ Please create tests first using 'create_tests' before recording test results!");
+  }
+
+  if (
+    typeof args.passed !== "boolean" ||
+    typeof args.testCommand !== "string" ||
+    args.testCommand.trim() === ""
+  ) {
+    return textResponse(
+      "⚠️ Please provide both 'passed' (boolean) and 'testCommand' (non-empty string) when recording test results."
+    );
+  }
+
+  workflowState.state.testsPassed = args.passed;
+  workflowState.state.testCommand = args.testCommand;
+  workflowState.state.testDetails = typeof args.details === "string" ? args.details : "";
+  workflowState.state.testsSkipped = false;
+  workflowState.state.testsSkippedReason = "";
+  workflowState.state.readyCheckCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.releaseSkipped = false;
+  workflowState.state.releaseSkippedReason = "";
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.lastCommitMessage = "";
+  workflowState.state.lastPushBranch = "";
+
+  if (!args.passed) {
+    workflowState.state.currentPhase = "testing";
+    await workflowState.save();
+
+    return textResponse(
+      `❌ TESTS FAILED!\n\n🚫 STOP! DO NOT COMMIT OR PUSH!\n\nYou must:\n1. Fix the failing tests\n2. Run tests again until they pass\n\nTest command: ${args.testCommand}\n\nNever skip or ignore failing tests!`
+    );
+  }
+
+  workflowState.state.currentPhase = "documentation";
+  await workflowState.save();
+
+  return textResponse(
+    `✅ All tests passed! 🎉\n\nTest command: ${args.testCommand}\n\n📝 Now create or update documentation using 'create_documentation' with:\n- documentationType: "PRD", "README", "RELEASE_NOTES", "inline-comments", "API-docs", "changelog", or "other"\n- summary: Brief description of what was documented\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. ⏳ Run 'commit_and_push'\n7. ⏳ Run 'perform_release' (or use 'skip_release' if no release is needed)\n8. ⏳ Complete task`
+  );
+}
+
+export async function handleCreateDocumentation(args, workflowState) {
+  if (!workflowState.state.testsPassed) {
+    return textResponse("⚠️ Please ensure tests are passing first! Run 'run_tests' with passed=true.");
+  }
+
+  const prdPath = path.join(process.cwd(), "docs", "PRD.md");
+  const prdExists = existsSync(prdPath);
+
+  if (!prdExists) {
+    return textResponse(
+      `⚠️ PRD file not found!\n\nExpected location: docs/PRD.md\n\nPlease create or update the PRD before marking documentation as complete.`
+    );
+  }
+
+  workflowState.state.documentationCreated = true;
+  workflowState.state.documentationType = args.documentationType;
+  workflowState.state.documentationSummary = args.summary;
+  workflowState.state.currentPhase = "ready";
+  workflowState.state.readyToCommit = true;
+  workflowState.state.readyCheckCompleted = false;
+  workflowState.state.released = false;
+  workflowState.state.releaseSkipped = false;
+  workflowState.state.releaseSkippedReason = "";
+  workflowState.state.commitAndPushCompleted = false;
+  workflowState.state.lastCommitMessage = "";
+  workflowState.state.lastPushBranch = "";
+  await workflowState.save();
+
+  return textResponse(
+    `✅ Documentation created/updated!\n\nType: ${args.documentationType}\nSummary: ${args.summary}\n✅ PRD verified: docs/product/PRD.md exists\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/update documentation\n5. ⏳ Run 'check_ready_to_commit' to verify\n6. ⏳ Run 'commit_and_push'\n7. ⏳ Run 'perform_release' (or 'skip_release' when applicable)\n8. ⏳ Mark as complete with 'complete_task'`
+  );
+}

package/tools/handlers-new.js

@@ -0,0 +1 @@
+export { handleToolCall } from "./handler-modules/index.js";