@programinglive/dev-workflow-mcp-server 1.1.6 → 1.1.11

package/tests/handlers.test.js

@@ -96,6 +96,294 @@ test("commit_and_push commits changes and pushes", async () => {
   });
 });
 
+test("run_full_workflow iterates until commit/release complete with clean tree", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.taskDescription = "Ship feature";
+    workflowState.state.taskType = "feature";
+    workflowState.state.currentPhase = "commit";
+    workflowState.state.bugFixed = true;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.documentationCreated = true;
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.commitAndPushCompleted = false;
+    workflowState.state.released = false;
+    workflowState.state.documentationType = "README";
+    workflowState.state.documentationSummary = "Docs";
+    workflowState.state.fixSummary = "Feature done";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "chore: existing",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("run_full_workflow", {
+        summary: "Feature done",
+        testCommand: "npm test",
+        documentationType: "README",
+        documentationSummary: "Docs",
+        commitMessage: "feat: ship feature",
+        releaseCommand: "npm run release:patch",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("✅ Full workflow completed successfully"),
+      "run_full_workflow should finish even when commit is already clean"
+    );
+    assert.ok(
+      response.content[0].text.includes("🎉 Cheers!"),
+      "run_full_workflow should include celebration message"
+    );
+    assert.equal(commands.includes("npm run release:patch"), true, "release command should run");
+    assert.equal(workflowState.state.currentPhase, "idle");
+    assert.equal(workflowState.state.history.length, 1);
+  });
+});
+
+test("project_summary_data reads persisted file and falls back", async () => {
+  await withWorkflowState(async (workflowState) => {
+    // Seed some history
+    workflowState.addToHistory({ taskDescription: "Add login feature", taskType: "feature", commitMessage: "feat: login" });
+    await workflowState.save(); // This should create project-summary.json
+
+    const response = await handleToolCall({
+      request: createRequest("project_summary_data", {}),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {},
+      utils,
+    });
+
+    const text = response.content[0].text;
+    assert.ok(text.includes("from persisted data"), "should indicate persisted source");
+    assert.ok(text.includes("Total tasks completed: 1"), "should count tasks");
+    assert.ok(text.includes("feature: 1"), "should show feature count");
+    assert.ok(text.includes("Updated:"), "should show updated timestamp");
+  });
+});
+
+test("project_summary aggregates task types and recent activity", async () => {
+  await withWorkflowState(async (workflowState) => {
+    // Seed some history
+    workflowState.addToHistory({ taskDescription: "Add login feature", taskType: "feature", commitMessage: "feat: login" });
+    workflowState.addToHistory({ taskDescription: "Fix auth bug", taskType: "bugfix", commitMessage: "fix: auth" });
+    workflowState.addToHistory({ taskDescription: "Refactor utils", taskType: "refactor", commitMessage: "refactor: utils" });
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("project_summary", {}),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {},
+      utils,
+    });
+
+    const text = response.content[0].text;
+    assert.ok(text.includes("Project Knowledge Summary"), "should include summary title");
+    assert.ok(text.includes("Total tasks completed: 3"), "should count tasks");
+    assert.ok(text.includes("feature: 1"), "should show feature count");
+    assert.ok(text.includes("bugfix: 1"), "should show bugfix count");
+    assert.ok(text.includes("refactor: 1"), "should show refactor count");
+    assert.ok(text.includes("Add login feature"), "should list recent tasks");
+  });
+});
+
+test("run_full_workflow executes all steps successfully", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.taskDescription = "Ship feature";
+    workflowState.state.taskType = "feature";
+    workflowState.state.currentPhase = "coding";
+    await workflowState.save();
+
+    const commands = [];
+    let workingChanges = true;
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command.startsWith("git commit") || command.startsWith("git push")) {
+        workingChanges = false;
+      }
+      if (command === "git status --porcelain") {
+        return { stdout: workingChanges ? " M src/app.js" : "" };
+      }
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => workingChanges,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [{ status: "M", path: "src/app.js" }],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () =>
+        workingChanges
+          ? { hasChanges: true, lines: ["M src/app.js"] }
+          : { hasChanges: false, lines: [] },
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("run_full_workflow", {
+        summary: "Implement feature",
+        testCommand: "npm test",
+        documentationType: "README",
+        documentationSummary: "Document feature",
+        commitMessage: "feat: add feature",
+        releaseCommand: "npm run release:patch",
+        releaseNotes: "Automated release",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("✅ Full workflow completed successfully"),
+      "run_full_workflow should report success"
+    );
+    assert.ok(
+      commands.some((command) => command.startsWith("git add")),
+      "git add should be executed"
+    );
+    assert.ok(
+      commands.some((command) => command.startsWith("git commit")),
+      "git commit should be executed"
+    );
+    assert.ok(
+      commands.some((command) => command.startsWith("git push")),
+      "git push should be executed"
+    );
+    assert.ok(
+      commands.some((command) => command.startsWith("npm run release")),
+      "release command should be executed"
+    );
+    assert.equal(workflowState.state.currentPhase, "idle");
+  });
+});
+
+test("run_full_workflow resumes from current phase when steps are already completed", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.taskDescription = "Ship feature";
+    workflowState.state.taskType = "feature";
+    workflowState.state.currentPhase = "release";
+    workflowState.state.bugFixed = true;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.documentationCreated = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.commitAndPushCompleted = true;
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      if (command === "git status --porcelain") {
+        return { stdout: "" };
+      }
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => false,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [],
+      getCurrentBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("run_full_workflow", {
+        summary: "Implement feature",
+        testCommand: "npm test",
+        documentationType: "README",
+        documentationSummary: "Document feature",
+        commitMessage: "feat: add feature",
+        releaseCommand: "npm run release:patch",
+        releaseNotes: "Automated release",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("✅ Full workflow completed successfully"),
+      "run_full_workflow should report success"
+    );
+    // Should only run release and complete since earlier steps are done
+    assert.ok(
+      commands.some((command) => command.startsWith("npm run release")),
+      "release command should be executed"
+    );
+    assert.equal(
+      commands.filter((c) => c.startsWith("git commit")).length,
+      0,
+      "git commit should not be executed when already completed"
+    );
+    assert.equal(workflowState.state.currentPhase, "idle");
+  });
+});
+
+test("run_full_workflow validates required arguments", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.taskDescription = "Ship feature";
+    workflowState.state.taskType = "feature";
+    workflowState.state.currentPhase = "coding";
+    await workflowState.save();
+
+    const response = await handleToolCall({
+      request: createRequest("run_full_workflow", {
+        summary: "",
+        testCommand: "npm test",
+        documentationType: "README",
+        documentationSummary: "Doc",
+        commitMessage: "feat: add feature",
+        releaseCommand: "npm run release:patch",
+      }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: async () => ({ stdout: "" }),
+      git: {},
+      utils,
+    });
+
+    assert.ok(
+      response.content[0].text.includes("Provide a non-empty 'summary'"),
+      "run_full_workflow should validate required fields"
+    );
+  });
+});
+
 test("force_complete_task records entry and resets state", async () => {
   await withWorkflowState(async (workflowState) => {
     workflowState.state.taskDescription = "Improve caching";

package/tests/release-wrapper.test.js

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile, readFile } from "node:fs/promises";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -10,7 +10,9 @@ const RELEASE_WRAPPER = path.join(PROJECT_ROOT, "release-wrapper.js");
 
 async function runWrapper({ state, args = ["patch"], env = {} }) {
   const dir = await mkdtemp(path.join(tmpdir(), "release-wrapper-test-"));
-  const statePath = path.join(dir, ".workflow-state.json");
+  const stateDir = path.join(dir, ".state");
+  const statePath = path.join(stateDir, "workflow-state.json");
+  await mkdir(stateDir, { recursive: true });
   await writeFile(statePath, JSON.stringify(state, null, 2));
 
   const childEnv = {

package/tests/workflowState.test.js

@@ -1,8 +1,19 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import {
+  mkdtemp,
+  rm,
+  mkdir,
+  realpath,
+  readFile,
+  writeFile,
+  access,
+  copyFile,
+} from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   WorkflowState,
   getNextStep,
@@ -25,6 +36,161 @@ async function withWorkflowState(callback) {
   }
 }
 
+test("WorkflowState mirrors state file to compatibility locations", async () => {
+  const tempRoot = await mkdtemp(path.join(tmpdir(), "workflow-compat-"));
+  const moduleDir = path.join(tempRoot, "module");
+  const projectRoot = path.join(tempRoot, "project");
+  const stateDir = path.join(projectRoot, ".state");
+  const sourceModulePath = fileURLToPath(new URL("../workflow-state.js", import.meta.url));
+  await mkdir(moduleDir, { recursive: true });
+  await mkdir(path.join(moduleDir, "dist"), { recursive: true });
+  await mkdir(path.join(tempRoot, "dist"), { recursive: true });
+  await mkdir(stateDir, { recursive: true });
+  await copyFile(sourceModulePath, path.join(moduleDir, "workflow-state.js"));
+  await writeFile(path.join(projectRoot, "package.json"), JSON.stringify({ name: "temp" }));
+
+  const stateFile = path.join(stateDir, "workflow-state.json");
+  await writeFile(stateFile, JSON.stringify({ currentPhase: "testing" }, null, 2));
+
+  const moduleUrl = pathToFileURL(path.join(moduleDir, "workflow-state.js"));
+  const { WorkflowState: TempWorkflowState } = await import(moduleUrl.href);
+
+  const state = new TempWorkflowState(stateFile);
+  await state.load();
+  state.state.currentPhase = "commit";
+  await state.save();
+
+  // Ensure primary state file was written correctly
+  const primaryContent = await readFile(stateFile, "utf-8");
+  const primaryParsed = JSON.parse(primaryContent);
+  assert.equal(primaryParsed.currentPhase, "commit", "primary state file should be updated");
+
+  await rm(tempRoot, { recursive: true, force: true });
+});
+
+test("WorkflowState avoids filesystem root when no project markers found", async () => {
+  const tempRoot = await mkdtemp(path.join(tmpdir(), "workflow-rootless-"));
+  const moduleDir = path.join(tempRoot, "module");
+  await mkdir(moduleDir, { recursive: true });
+
+  const sourceModulePath = fileURLToPath(new URL("../workflow-state.js", import.meta.url));
+  await copyFile(sourceModulePath, path.join(moduleDir, "workflow-state.js"));
+
+  const moduleUrl = pathToFileURL(path.join(moduleDir, "workflow-state.js"));
+  const { WorkflowState: TempWorkflowState } = await import(moduleUrl.href);
+
+  const originalCwd = process.cwd();
+  const initWasSet = Object.prototype.hasOwnProperty.call(process.env, "INIT_CWD");
+  const originalInitCwd = process.env.INIT_CWD;
+
+  try {
+    const cwdWithoutMarkers = path.join(tempRoot, "random", "deep");
+    await mkdir(cwdWithoutMarkers, { recursive: true });
+
+    process.chdir(cwdWithoutMarkers);
+    process.env.INIT_CWD = cwdWithoutMarkers;
+
+    const state = new TempWorkflowState();
+    const resolvedTempRoot = await realpath(tempRoot);
+
+    assert.ok(
+      state.stateFile.startsWith(path.join(resolvedTempRoot, ".state")),
+      "state file should resolve under temp root when no project markers exist"
+    );
+    assert.ok(
+      !state.stateFile.startsWith(path.join(path.sep, ".state")),
+      "state file should not resolve to filesystem root"
+    );
+  } finally {
+    process.chdir(originalCwd);
+    if (initWasSet) {
+      process.env.INIT_CWD = originalInitCwd;
+    } else {
+      delete process.env.INIT_CWD;
+    }
+
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test("resolveUserId persists generated ID", async () => {
+  const projectRoot = await mkdtemp(path.join(tmpdir(), "workflow-userid-"));
+  await writeFile(path.join(projectRoot, "package.json"), JSON.stringify({ name: "temp" }));
+
+  const originalCwd = process.cwd();
+  const initWasSet = Object.prototype.hasOwnProperty.call(process.env, "INIT_CWD");
+  const originalInitCwd = process.env.INIT_CWD;
+  const userEnvWasSet = Object.prototype.hasOwnProperty.call(process.env, "DEV_WORKFLOW_USER_ID");
+  const originalUserEnv = process.env.DEV_WORKFLOW_USER_ID;
+
+  try {
+    process.chdir(projectRoot);
+    process.env.INIT_CWD = projectRoot;
+    if (userEnvWasSet) {
+      delete process.env.DEV_WORKFLOW_USER_ID;
+    }
+
+    const firstModuleHref = new URL("../workflow-state.js?resolveUserId1", import.meta.url).href;
+    const { WorkflowState: FirstWorkflowState } = await import(firstModuleHref);
+
+    const state = new FirstWorkflowState();
+    await state.ensurePrimaryFile();
+
+    const userDir = path.dirname(state.stateFile);
+    const userId = path.basename(userDir);
+    assert.ok(userId.startsWith("user-"), "Generated user ID should use user- prefix");
+
+    const userIdFile = path.join(projectRoot, ".state", "user-id");
+    const persistedId = (await readFile(userIdFile, "utf-8")).trim();
+    assert.equal(persistedId, userId, "user-id file should match generated user ID");
+
+    const secondModuleHref = new URL("../workflow-state.js?resolveUserId2", import.meta.url).href;
+    const { WorkflowState: SecondWorkflowState } = await import(secondModuleHref);
+
+    const reloadedState = new SecondWorkflowState();
+    await reloadedState.ensurePrimaryFile();
+
+    assert.equal(reloadedState.stateFile, state.stateFile, "State file path should persist across reloads");
+    const reloadedUserId = path.basename(path.dirname(reloadedState.stateFile));
+    assert.equal(reloadedUserId, userId, "Reloaded module should reuse persisted user ID");
+  } finally {
+    process.chdir(originalCwd);
+    if (initWasSet) {
+      process.env.INIT_CWD = originalInitCwd;
+    } else {
+      delete process.env.INIT_CWD;
+    }
+    if (userEnvWasSet) {
+      process.env.DEV_WORKFLOW_USER_ID = originalUserEnv;
+    } else {
+      delete process.env.DEV_WORKFLOW_USER_ID;
+    }
+    await rm(projectRoot, { recursive: true, force: true });
+  }
+});
+
+test("WorkflowState generates project summary on load and updates on save", async () => {
+  await withWorkflowState(async (state) => {
+    const summaryPath = path.join(path.dirname(state.stateFile), "project-summary.json");
+
+    const initialSummary = JSON.parse(await readFile(summaryPath, "utf-8"));
+    assert.equal(initialSummary.totalTasks, 0);
+    assert.deepEqual(initialSummary.taskTypes, {});
+
+    state.addToHistory({
+      taskDescription: "Seed summary",
+      taskType: "feature",
+      commitMessage: "feat: seed",
+    });
+    await state.save();
+
+    const updatedSummary = JSON.parse(await readFile(summaryPath, "utf-8"));
+    assert.equal(updatedSummary.totalTasks, 1);
+    assert.equal(updatedSummary.taskTypes.feature, 1);
+    assert.equal(updatedSummary.recentTasks[0].description, "Seed summary");
+  });
+});
+
 test("WorkflowState persists data across save/load", async () => {
   await withWorkflowState(async (state) => {
     state.state.currentPhase = "testing";
@@ -64,6 +230,59 @@ test("WorkflowState persists data across save/load", async () => {
   });
 });
 
+test("WorkflowState resolves state file relative to project root", async () => {
+  const projectRoot = await mkdtemp(path.join(tmpdir(), "workflow-project-"));
+  const originalCwd = process.cwd();
+  const initWasSet = Object.prototype.hasOwnProperty.call(process.env, "INIT_CWD");
+  const originalInitCwd = process.env.INIT_CWD;
+  const devStateWasSet = Object.prototype.hasOwnProperty.call(
+    process.env,
+    "DEV_WORKFLOW_STATE_FILE"
+  );
+  const originalDevState = process.env.DEV_WORKFLOW_STATE_FILE;
+
+  try {
+    await mkdir(path.join(projectRoot, ".git"));
+    const nestedDir = path.join(projectRoot, "dist", "server");
+    await mkdir(nestedDir, { recursive: true });
+
+    process.chdir(projectRoot);
+    process.env.INIT_CWD = projectRoot;
+    if (devStateWasSet) {
+      delete process.env.DEV_WORKFLOW_STATE_FILE;
+    }
+    const state = new WorkflowState();
+    assert.ok(
+      state.stateFile.startsWith(path.join(projectRoot, ".state", "users")),
+      "state file should resolve under project .state/users directory"
+    );
+
+    process.chdir(nestedDir);
+    delete process.env.INIT_CWD;
+    delete process.env.DEV_WORKFLOW_STATE_FILE;
+
+    const state2 = new WorkflowState();
+    const resolvedProjectRoot = await realpath(projectRoot);
+    assert.ok(
+      state2.stateFile.startsWith(path.join(resolvedProjectRoot, ".state", "users")),
+      "state file should resolve to project root"
+    );
+  } finally {
+    process.chdir(originalCwd);
+    if (initWasSet) {
+      process.env.INIT_CWD = originalInitCwd;
+    } else {
+      delete process.env.INIT_CWD;
+    }
+    if (devStateWasSet) {
+      process.env.DEV_WORKFLOW_STATE_FILE = originalDevState;
+    } else {
+      delete process.env.DEV_WORKFLOW_STATE_FILE;
+    }
+    await rm(projectRoot, { recursive: true, force: true });
+  }
+});
+
 test("WorkflowState reset keeps history but clears progress", async () => {
   await withWorkflowState(async (state) => {
     state.state.currentPhase = "ready";

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: {},
+      },
+    },
   ];
 }