@programinglive/dev-workflow-mcp-server 1.1.7 → 1.1.16

package/tools/definitions.js

@@ -225,5 +225,108 @@ export function getToolList() {
         properties: {},
       },
     },
+    {
+      name: "rerun_workflow",
+      description:
+        "Reset and restart the current task from the beginning. Useful when you want to replay the entire workflow from start to finish.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
+    {
+      name: "run_full_workflow",
+      description:
+        "Execute every workflow step in sequence using the provided arguments (mark fixed → tests → run tests → docs → ready check → commit → release → complete).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          summary: {
+            type: "string",
+            description: "Brief summary recorded when marking the bug/feature as fixed",
+          },
+          testsPassed: {
+            type: "boolean",
+            description: "Whether tests passed (defaults to true)",
+          },
+          testCommand: {
+            type: "string",
+            description: "Command used to run tests",
+          },
+          testDetails: {
+            type: "string",
+            description: "Additional test output or notes",
+          },
+          documentationType: {
+            type: "string",
+            enum: ["README", "inline-comments", "API-docs", "changelog", "other"],
+            description: "Type of documentation created",
+          },
+          documentationSummary: {
+            type: "string",
+            description: "Summary of documentation updates",
+          },
+          commitMessage: {
+            type: "string",
+            description: "Commit message used for commit_and_push and complete_task",
+          },
+          branch: {
+            type: "string",
+            description: "Optional branch name to push to",
+          },
+          releaseCommand: {
+            type: "string",
+            description: "Release command executed during perform_release",
+          },
+          releaseNotes: {
+            type: "string",
+            description: "Optional release notes to record",
+          },
+          releaseType: {
+            type: "string",
+            description: "Optional release type override (major/minor/patch)",
+          },
+          preset: {
+            type: "string",
+            description: "Optional preset argument for perform_release",
+          },
+        },
+        required: [
+          "summary",
+          "testCommand",
+          "documentationType",
+          "documentationSummary",
+          "commitMessage",
+          "releaseCommand",
+        ],
+      },
+    },
+    {
+      name: "project_summary",
+      description:
+        "Get a project knowledge summary that aggregates completed tasks, task types, and recent activity to help understand the project and fix bugs faster over time.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
+    {
+      name: "project_summary_data",
+      description:
+        "Get the persisted project knowledge summary from a structured JSON file (project-summary.json). Falls back to in-memory if the file doesn't exist. This file can be used as a simple database for future features.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
+    {
+      name: "project_summary_db",
+      description:
+        "Get the per-user project knowledge summary from SQLite. Use DEV_WORKFLOW_USER_ID env var to isolate users.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+      },
+    },
   ];
 }

package/tools/handlers.js

@@ -1,3 +1,12 @@
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_SUMMARY_FILENAME = "project-summary.json";
+
 const textResponse = (text) => ({
   content: [
     {
@@ -48,6 +57,30 @@ function summarizeHistory(history, limit) {
   return `📜 Workflow History (last ${recent.length} tasks)\n\n${historyText}`;
 }
 
+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")}`;
+}
+
 function getContinueGuidance(status) {
   switch (status.currentPhase) {
     case "coding": {
@@ -162,6 +195,29 @@ async function handleMarkBugFixed(args, workflowState) {
     return textResponse("⚠️ Please start a task first using 'start_task'!");
   }
 
+  // Idempotent behavior: if already marked fixed, do not reset downstream flags.
+  if (workflowState.state.bugFixed) {
+    const summary = typeof args.summary === "string" ? args.summary : "";
+    if (summary && summary.trim() !== "") {
+      workflowState.state.fixSummary = summary;
+    }
+
+    // Preserve existing progress and set an appropriate phase.
+    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";
@@ -358,14 +414,12 @@ async function handleReadyCheck(workflowState) {
 
 async function handleCommitAndPush(args, context) {
   const { workflowState, exec, git, utils } = context;
-  if (!workflowState.state.readyToCommit) {
-    return textResponse("⚠️ Not ready yet! Run 'check_ready_to_commit' and complete all steps first.");
-  }
-
-  if (!workflowState.state.readyCheckCompleted) {
-    return textResponse(
-      "⚠️ Please run 'check_ready_to_commit' and resolve any outstanding items before committing!"
-    );
+  if (!workflowState.state.readyToCommit || !workflowState.state.readyCheckCompleted) {
+    // Be smart: auto-run the ready check and proceed if it passes.
+    const readyResponse = await handleReadyCheck(workflowState);
+    if (workflowState.state.currentPhase !== "commit") {
+      return readyResponse;
+    }
   }
 
   const providedCommitMessage =
@@ -696,6 +750,195 @@ function handleViewHistory(args, workflowState) {
   return textResponse(message);
 }
 
+function handleProjectSummary(workflowState) {
+  const summary = generateProjectSummary(workflowState.state.history);
+  return textResponse(summary);
+}
+
+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) {
+    // Fallback to in-memory generation if file doesn't exist
+    return handleProjectSummary(workflowState);
+  }
+}
+
+async function handleProjectSummaryDb(workflowState) {
+  const { getSummaryForUser } = await import("../db/index.js");
+  const userId = process.env.DEV_WORKFLOW_USER_ID || "default";
+  const summary = getSummaryForUser(userId);
+  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);
+}
+
+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!`
+  );
+}
+
+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 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;
+  }
+
+  // Smart flow: detect current phase and run only remaining steps
+  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: typeof args.branch === "string" ? args.branch : "",
+        },
+        { workflowState, exec, git, utils },
+      ]);
+      if (isErrorResponse(resp)) return resp;
+      continue;
+    }
+
+    if (!state.released) {
+      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,
@@ -741,8 +984,18 @@ export async function handleToolCall({
         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}`);
     }

package/vite.config.js

@@ -0,0 +1,43 @@
+import { defineConfig } from 'vite';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default defineConfig({
+  build: {
+    target: 'node18',
+    outDir: 'dist',
+    minify: false,
+    rollupOptions: {
+      input: path.resolve(__dirname, 'index.js'),
+      output: {
+        entryFileNames: 'index.mjs',
+        format: 'es',
+      },
+      external: [
+        '@modelcontextprotocol/sdk',
+        // Node.js built-in modules
+        'node:fs',
+        'node:path',
+        'node:url',
+        'node:util',
+        'node:os',
+        'node:process',
+        'node:child_process',
+        'fs',
+        'fs/promises',
+        'path',
+        'url',
+        'util',
+        'os',
+        'process',
+        'child_process',
+      ],
+    },
+  },
+  define: {
+    __filename: JSON.stringify(path.resolve(__dirname, 'index.js')),
+  },
+});