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

package/tests/handlers.test.js

@@ -62,6 +62,7 @@ test("commit_and_push commits changes and pushes", async () => {
       hasTestChanges: async () => true,
       getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
       getCurrentBranch: async () => "main",
+      getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
@@ -129,6 +130,7 @@ test("run_full_workflow iterates until commit/release complete with clean tree",
       hasTestChanges: async () => true,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
+      getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "chore: existing",
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
@@ -163,6 +165,172 @@ test("run_full_workflow iterates until commit/release complete with clean tree",
   });
 });
 
+test("commit_and_push uses primary branch when no branch specified", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => true,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
+      getCurrentBranch: async () => "feature/test",
+      getPrimaryBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "feat: test" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    const pushCommand = commands.find((command) => command.startsWith("git push"));
+    assert.ok(pushCommand, "git push should be executed");
+    assert.ok(
+      pushCommand.includes("main"),
+      "push command should use detected primary branch (main)"
+    );
+    assert.ok(
+      response.content[0].text.includes("Commit and push completed!"),
+      "response should confirm commit and push"
+    );
+  });
+});
+
+test("commit_and_push falls back to master when main not found", async () => {
+  await withWorkflowState(async (workflowState) => {
+    workflowState.state.readyToCommit = true;
+    workflowState.state.readyCheckCompleted = true;
+    workflowState.state.testsSkipped = false;
+    workflowState.state.testsCreated = true;
+    workflowState.state.testsPassed = true;
+    workflowState.state.currentPhase = "commit";
+    await workflowState.save();
+
+    const commands = [];
+    const execStub = async (command) => {
+      commands.push(command);
+      return { stdout: "" };
+    };
+
+    const git = {
+      hasWorkingChanges: async () => true,
+      hasStagedChanges: async () => false,
+      hasTestChanges: async () => true,
+      getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
+      getCurrentBranch: async () => "feature/test",
+      getPrimaryBranch: async () => "master",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const response = await handleToolCall({
+      request: createRequest("commit_and_push", { commitMessage: "feat: test" }),
+      normalizeRequestArgs,
+      workflowState,
+      exec: execStub,
+      git,
+      utils,
+    });
+
+    const pushCommand = commands.find((command) => command.startsWith("git push"));
+    assert.ok(pushCommand, "git push should be executed");
+    assert.ok(
+      pushCommand.includes("master"),
+      "push command should use detected primary branch (master)"
+    );
+  });
+});
+
+test("run_full_workflow uses provided branch for release push when commit is clean", 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 () => "feature/local",
+      getPrimaryBranch: async () => "main",
+      getLastCommitMessage: async () => "chore: existing",
+      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+    };
+
+    const branchName = "master";
+    const response = await handleToolCall({
+      request: createRequest("run_full_workflow", {
+        summary: "Feature done",
+        testCommand: "npm test",
+        documentationType: "README",
+        documentationSummary: "Docs",
+        commitMessage: "feat: ship feature",
+        branch: branchName,
+        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 successfully"
+    );
+
+    const tagPushCommand = commands.find((command) => command.startsWith("git push --follow-tags"));
+    assert.ok(tagPushCommand, "release should push tags");
+    assert.ok(
+      /origin\s+'?master'?/.test(tagPushCommand),
+      `release push should target the provided branch (${branchName})`
+    );
+
+    assert.equal(workflowState.state.currentPhase, "idle");
+  });
+});
+
 test("project_summary_data reads persisted file and falls back", async () => {
   await withWorkflowState(async (workflowState) => {
     // Seed some history
@@ -174,7 +342,16 @@ test("project_summary_data reads persisted file and falls back", async () => {
       normalizeRequestArgs,
       workflowState,
       exec: async () => ({ stdout: "" }),
-      git: {},
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "",
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
       utils,
     });
 
@@ -199,7 +376,16 @@ test("project_summary aggregates task types and recent activity", async () => {
       normalizeRequestArgs,
       workflowState,
       exec: async () => ({ stdout: "" }),
-      git: {},
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "",
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
       utils,
     });
 
@@ -239,6 +425,7 @@ test("run_full_workflow executes all steps successfully", async () => {
       hasTestChanges: async () => true,
       getStagedChanges: async () => [{ status: "M", path: "src/app.js" }],
       getCurrentBranch: async () => "main",
+      getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
       workingTreeSummary: () =>
         workingChanges
@@ -315,6 +502,7 @@ test("run_full_workflow resumes from current phase when steps are already comple
       hasTestChanges: async () => true,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
+      getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
@@ -373,7 +561,16 @@ test("run_full_workflow validates required arguments", async () => {
       normalizeRequestArgs,
       workflowState,
       exec: async () => ({ stdout: "" }),
-      git: {},
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "",
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
       utils,
     });
 
@@ -400,7 +597,16 @@ test("force_complete_task records entry and resets state", async () => {
       normalizeRequestArgs,
       workflowState,
       exec: async () => ({ stdout: "" }),
-      git: {},
+      git: {
+        hasWorkingChanges: async () => false,
+        hasStagedChanges: async () => false,
+        hasTestChanges: async () => true,
+        getStagedChanges: async () => [],
+        getCurrentBranch: async () => "main",
+        getPrimaryBranch: async () => "main",
+        getLastCommitMessage: async () => "",
+        workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      },
       utils,
     });
 
@@ -436,7 +642,8 @@ test("perform_release blocks when new changes detected", async () => {
       hasTestChanges: async () => true,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
-      getLastCommitMessage: async () => "fix: adjust layout",
+      getPrimaryBranch: async () => "main",
+      getLastCommitMessage: async () => "",
       workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
     };
 
@@ -466,6 +673,7 @@ test("continue_workflow warns when workflow is idle", async () => {
       hasTestChanges: async () => false,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
+      getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "",
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };
@@ -499,8 +707,9 @@ test("continue_workflow resets to commit when new changes detected", async () =>
       hasTestChanges: async () => true,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
-      getLastCommitMessage: async () => "fix: adjust layout",
-      workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
+      getPrimaryBranch: async () => "main",
+      getLastCommitMessage: async () => "",
+      workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
     };
 
     const response = await handleToolCall({
@@ -543,6 +752,7 @@ test("commit_and_push recognizes already committed work", async () => {
       hasTestChanges: async () => true,
       getStagedChanges: async () => [],
       getCurrentBranch: async () => "main",
+      getPrimaryBranch: async () => "main",
       getLastCommitMessage: async () => "fix: previous work",
       workingTreeSummary: () => ({ hasChanges: false, lines: [] }),
     };

package/tests/release-wrapper.test.js

@@ -3,10 +3,14 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 
-const PROJECT_ROOT = path.resolve(new URL("..", import.meta.url).pathname);
-const RELEASE_WRAPPER = path.join(PROJECT_ROOT, "release-wrapper.js");
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const releaseWrapperUrl = new URL("../release-wrapper.js", import.meta.url);
+const RELEASE_WRAPPER = fileURLToPath(releaseWrapperUrl);
+const PROJECT_ROOT = path.dirname(RELEASE_WRAPPER);
 
 async function runWrapper({ state, args = ["patch"], env = {} }) {
   const dir = await mkdtemp(path.join(tmpdir(), "release-wrapper-test-"));
@@ -22,14 +26,18 @@ async function runWrapper({ state, args = ["patch"], env = {} }) {
     ...env,
   };
 
+  const nodeBinary = process.platform === "win32" ? "node" : process.execPath || "node";
+  const spawnShell = process.platform === "win32";
+
   return await new Promise((resolve) => {
     const child = spawn(
-      process.execPath,
+      nodeBinary,
       [RELEASE_WRAPPER, ...args],
       {
         cwd: PROJECT_ROOT,
         env: childEnv,
         stdio: ["ignore", "pipe", "pipe"],
+        shell: spawnShell,
       }
     );
 

package/tests/workflowState.test.js

@@ -36,6 +36,58 @@ async function withWorkflowState(callback) {
   }
 }
 
+test("resolveStateFile prefers current working directory when multiple project markers exist", async () => {
+  const tempRoot = await mkdtemp(path.join(tmpdir(), "workflow-prefers-cwd-"));
+  const moduleDir = path.join(tempRoot, "module");
+  const projectA = path.join(tempRoot, "project-a");
+  const projectB = path.join(tempRoot, "project-b");
+  const projectBNested = path.join(projectB, "sub", "app");
+
+  await mkdir(moduleDir, { recursive: true });
+  await mkdir(projectA, { recursive: true });
+  await mkdir(projectBNested, { recursive: true });
+
+  const sourceModulePath = fileURLToPath(new URL("../workflow-state.js", import.meta.url));
+  await copyFile(sourceModulePath, path.join(moduleDir, "workflow-state.js"));
+
+  await writeFile(path.join(moduleDir, "package.json"), JSON.stringify({ name: "module" }));
+  await writeFile(path.join(projectA, "package.json"), JSON.stringify({ name: "project-a" }));
+  await writeFile(path.join(projectB, "package.json"), JSON.stringify({ name: "project-b" }));
+
+  const moduleUrl = pathToFileURL(path.join(moduleDir, "workflow-state.js"));
+  const { WorkflowState: TempWorkflowState } = await import(`${moduleUrl.href}?preferCwd=${Date.now()}`);
+
+  const originalCwd = process.cwd();
+  const initWasSet = Object.prototype.hasOwnProperty.call(process.env, "INIT_CWD");
+  const originalInitCwd = process.env.INIT_CWD;
+
+  try {
+    process.chdir(projectBNested);
+    process.env.INIT_CWD = projectA;
+
+    const state = new TempWorkflowState();
+    const resolvedStateFile = state.stateFile;
+
+    assert.ok(
+      resolvedStateFile.startsWith(path.join(projectB, ".state", "users")),
+      "State file should resolve under the current working directory's project"
+    );
+
+    assert.ok(
+      !resolvedStateFile.startsWith(path.join(projectA, ".state")),
+      "State file should not use INIT_CWD project when cwd has its own markers"
+    );
+  } 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("WorkflowState mirrors state file to compatibility locations", async () => {
   const tempRoot = await mkdtemp(path.join(tmpdir(), "workflow-compat-"));
   const moduleDir = path.join(tempRoot, "module");
@@ -94,8 +146,8 @@ test("WorkflowState avoids filesystem root when no project markers found", async
     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"
+      state.stateFile.startsWith(resolvedTempRoot),
+      "state file should remain inside the temporary root when no project markers exist"
     );
     assert.ok(
       !state.stateFile.startsWith(path.join(path.sep, ".state")),

package/tools/handlers.js

@@ -426,8 +426,9 @@ async function handleCommitAndPush(args, context) {
     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 || currentBranch || "";
+  const branchForPush = requestedBranch || primaryBranch || currentBranch || "";
 
   const hasWorkingChanges = await git.hasWorkingChanges();
 
@@ -817,6 +818,12 @@ async function handleRunFullWorkflow(args, { workflowState, exec, git, utils })
 
   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." },
@@ -906,7 +913,7 @@ async function handleRunFullWorkflow(args, { workflowState, exec, git, utils })
       const resp = await executeStep("commit_and_push", handleCommitAndPush, [
         {
           commitMessage: args.commitMessage,
-          branch: typeof args.branch === "string" ? args.branch : "",
+          branch: requestedBranch,
         },
         { workflowState, exec, git, utils },
       ]);