@programinglive/dev-workflow-mcp-server 1.13.10 → 1.13.12

package/git-facade.js

@@ -10,8 +10,10 @@
 
 import {
   getCurrentBranch,
+  getHeadSha,
   getLastCommitMessage,
   getPrimaryBranch,
+  getRemoteBranchSha,
   getStagedChanges,
   getStatusOutput,
   hasStagedChanges,
@@ -27,7 +29,9 @@ export function createGitFacade() {
     hasStagedChanges,
     getStagedChanges,
     getCurrentBranch,
+    getHeadSha,
     getPrimaryBranch,
+    getRemoteBranchSha,
     getLastCommitMessage,
     getStatusOutput,
     workingTreeSummary,

package/git-helpers.js

@@ -145,6 +145,29 @@ export async function getCurrentBranch() {
   return stdout.trim();
 }
 
+/**
+ * SHA commit yang sedang di HEAD.
+ *
+ * Dipakai untuk membuktikan bahwa push benar-benar mengirim commit ini, bukan
+ * hanya "git push" yang keluar 0 tanpa memindahkan apa pun.
+ */
+export async function getHeadSha() {
+  const { stdout } = await exec("git rev-parse HEAD");
+  return stdout.trim();
+}
+
+/**
+ * SHA yang tercatat pada remote-tracking ref `origin/<branch>`.
+ * Melempar bila branch itu belum ada di remote.
+ */
+export async function getRemoteBranchSha(branch) {
+  const { stdout } = await exec("git rev-parse", {
+    executable: "git",
+    arguments: ["rev-parse", `origin/${branch}`],
+  });
+  return stdout.trim();
+}
+
 export async function getStatusOutput() {
   const { stdout } = await exec("git status --porcelain");
   return stdout;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@programinglive/dev-workflow-mcp-server",
-  "version": "1.13.10",
+  "version": "1.13.12",
   "description": "MCP server to enforce development workflow discipline",
   "homepage": "https://devworkflow.programinglive.com/",
   "mcpName": "io.github.programinglive/dev-workflow-mcp-server",

package/scripts/verify-push-branch.mjs

@@ -0,0 +1,111 @@
+// Verifikasi end-to-end commit_and_push: harus mem-push branch AKTIF.
+// Memanggil handler asli (bukan mock) terhadap repo sementara + remote bare.
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { handleToolCall } from "../tools/handlers.js";
+import { WorkflowState } from "../workflow-state.js";
+import { shellEscape, normalizeRequestArgs } from "../utils.js";
+import { createCommitMessageParts, determineReleaseTypeFromCommit } from "../commit-helpers.js";
+import { createGitFacade } from "../git-facade.js";
+import { exec } from "../exec.js";
+
+const git = (cwd, ...args) =>
+  execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+
+const root = mkdtempSync(path.join(tmpdir(), "push-verify-"));
+const remote = path.join(root, "remote.git");
+const work = path.join(root, "work");
+
+try {
+  git(root, "init", "--bare", "-q", remote);
+  git(root, "clone", "-q", remote, work);
+  git(work, "config", "user.email", "test@example.test");
+  git(work, "config", "user.name", "Test");
+
+  writeFileSync(path.join(work, "base.txt"), "awal\n");
+  git(work, "add", ".");
+  git(work, "commit", "-q", "-m", "chore: initial");
+  git(work, "branch", "-M", "main");
+  git(work, "push", "-q", "origin", "main");
+
+  // Branch fitur dengan commit yang BELUM di-push.
+  git(work, "checkout", "-q", "-b", "feat/verifikasi");
+  writeFileSync(path.join(work, "fitur.txt"), "fitur\n");
+  git(work, "add", ".");
+  git(work, "commit", "-q", "-m", "feat: pekerjaan di branch fitur");
+
+  const headBefore = git(work, "rev-parse", "HEAD");
+  const mainBefore = git(work, "rev-parse", "main");
+
+  // Perubahan yang BELUM di-commit, supaya tool menempuh jalur commit + push
+  // (bukan jalur "no changes detected").
+  writeFileSync(path.join(work, "belum-commit.txt"), "perubahan\n");
+
+  console.log("branch aktif :", git(work, "branch", "--show-current"));
+  console.log("HEAD awal    :", headBefore.slice(0, 8));
+  let remoteFeatBefore = "(belum ada)";
+  try {
+    remoteFeatBefore = git(work, "rev-parse", "--verify", "-q", "origin/feat/verifikasi").slice(0, 8);
+  } catch { /* belum ada */ }
+  console.log("origin/feat  :", remoteFeatBefore);
+
+  const stateFile = path.join(root, "state.json");
+  const workflowState = new WorkflowState(stateFile);
+  await workflowState.load();
+  Object.assign(workflowState.state, {
+    currentPhase: "commit",
+    taskDescription: "verifikasi push branch",
+    taskType: "other",
+    featureFlowCreated: true,
+    bugFixed: true,
+    testsCreated: true,
+    testsPassed: true,
+    testsSkipped: true,
+    documentationCreated: true,
+    readyToCommit: true,
+    readyCheckCompleted: true,
+    commitAndPushCompleted: false,
+    projectDir: work,
+    history: [],
+  });
+  await workflowState.save();
+
+  const response = await handleToolCall({
+    request: {
+      params: {
+        name: "commit_and_push",
+        arguments: { commitMessage: "feat: uji push", projectDir: work },
+      },
+    },
+    normalizeRequestArgs,
+    workflowState,
+    exec,
+    git: createGitFacade(),
+    utils: { shellEscape, determineReleaseTypeFromCommit, createCommitMessageParts },
+  });
+
+  console.log("\n=== output tool ===");
+  console.log(response.content[0].text);
+
+  console.log("\n=== hasil di remote ===");
+  let remoteFeat = "";
+  try {
+    remoteFeat = git(work, "rev-parse", "--verify", "-q", "origin/feat/verifikasi");
+  } catch { /* tidak ada */ }
+  const remoteMain = git(work, "rev-parse", "main");
+  console.log("origin/feat/verifikasi :", remoteFeat ? remoteFeat.slice(0, 8) : "(tidak ada)");
+  console.log("origin/main            :", remoteMain.slice(0, 8));
+
+  const headAfter = git(work, "rev-parse", "HEAD");
+  const okFeat = remoteFeat === headAfter;
+  const okMain = remoteMain === mainBefore;
+  console.log("");
+  console.log(okFeat ? "BENAR: remote menerima commit di branch fitur" : "SALAH: remote/feat tidak menerima HEAD");
+  console.log(okMain ? "BENAR: main tidak tersentuh" : "SALAH: main ikut berubah");
+  process.exitCode = okFeat && okMain ? 0 : 1;
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

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

@@ -43,6 +43,62 @@ function applyProjectDirOverride(args) {
   }
 }
 
+/**
+ * Branch yang benar-benar dipakai untuk push.
+ *
+ * Urutan: `branch` eksplisit -> branch aktif -> primary branch.
+ *
+ * Sebelum 31 Okt 2026 urutannya primaryBranch lebih dulu, dan `getPrimaryBranch()`
+ * selalu menjawab "main" bila `origin/main` ada - tanpa melihat branch aktif.
+ * Akibatnya di worktree yang sedang di `feat/...`, tool menjalankan
+ * `git push origin main`. Karena `main` lokal sudah sama dengan `origin/main`,
+ * perintah itu keluar 0 tanpa mengirim apa pun, lalu tool melaporkan
+ * "Commit and push completed". Dua commit nyata tidak pernah ter-push.
+ *
+ * HEAD yang detached ("HEAD") bukan branch, jadi tidak bisa dipakai.
+ */
+function pickPushBranch({ requestedBranch, currentBranch, primaryBranch }) {
+  if (requestedBranch) return requestedBranch;
+  if (currentBranch && currentBranch !== "HEAD") return currentBranch;
+  return primaryBranch || currentBranch || "";
+}
+
+/**
+ * Pastikan remote benar-benar menerima HEAD.
+ *
+ * `git push` bisa keluar 0 tanpa memindahkan apa pun - itulah yang menyamarkan
+ * bug di atas. Satu-satunya bukti yang bisa dipercaya adalah membandingkan SHA.
+ */
+async function verifyPushed(git, branch) {
+  let head;
+  try {
+    head = await git.getHeadSha();
+  } catch (error) {
+    return { ok: false, detail: `tidak bisa membaca HEAD: ${error.message}` };
+  }
+
+  let remote;
+  try {
+    remote = await git.getRemoteBranchSha(branch);
+  } catch {
+    return {
+      ok: false,
+      detail: `branch origin/${branch} tidak ditemukan di remote setelah push`,
+    };
+  }
+
+  if (remote !== head) {
+    return {
+      ok: false,
+      detail:
+        `origin/${branch} berada di ${remote.slice(0, 8)}, ` +
+        `sedangkan HEAD di ${head.slice(0, 8)}`,
+    };
+  }
+
+  return { ok: true, head };
+}
+
 export async function handleCommitAndPush(args, context) {
   const { workflowState, exec, git, utils } = context;
 
@@ -84,12 +140,25 @@ export async function handleCommitAndPush(args, context) {
     );
   }
 
-  const branchForPush = requestedBranch || primaryBranch || currentBranch || "";
+  const branchForPush = pickPushBranch({ requestedBranch, currentBranch, primaryBranch });
 
   if (!hasWorkingChanges) {
     const lastCommitMessage = await git.getLastCommitMessage();
     const effectiveCommitMessage = lastCommitMessage || providedCommitMessage;
 
+    // "Tidak ada perubahan" bukan berarti "sudah ter-push". HEAD bisa saja
+    // berupa commit yang belum pernah dikirim. Memeriksanya mencegah tool
+    // menandai selesai padahal remote masih tertinggal.
+    const pushed = await verifyPushed(git, branchForPush);
+    if (!pushed.ok) {
+      return textResponse(
+        `⚠️ Tidak ada perubahan untuk di-commit, tetapi HEAD BELUM ada di remote.\n` +
+        `Repo: ${repoLabel()}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
+        `Sebab: ${pushed.detail}\n\n` +
+        `Jalankan 'commit_and_push' lagi dengan 'branch' yang benar, atau push manual.`
+      );
+    }
+
     workflowState.state.commitAndPushCompleted = true;
     workflowState.state.lastCommitMessage = effectiveCommitMessage || "";
     workflowState.state.lastPushBranch = branchForPush;
@@ -97,7 +166,7 @@ export async function handleCommitAndPush(args, context) {
     await workflowState.save();
 
     return textResponse(
-      `ℹ️ No changes detected. Assuming commit and push already completed.\nRepo: ${repoLabel()}\nLast commit: ${effectiveCommitMessage || "(unavailable)"
+      `ℹ️ No changes detected. Assuming commit and push already completed.\nRepo: ${repoLabel()}\nBranch: ${branchForPush} (verified on remote)\nLast commit: ${effectiveCommitMessage || "(unavailable)"
       }\n\nNext: Run 'perform_release' to handle the release and push tags.`
     );
   }
@@ -152,6 +221,20 @@ export async function handleCommitAndPush(args, context) {
     );
   }
 
+  // Exit code 0 dari `git push` BUKAN bukti bahwa commit ini terkirim. Kalau
+  // branch yang dipilih sudah sinkron, git tidak melakukan apa pun dan tetap
+  // keluar 0. Satu-satunya bukti yang bisa dipercaya: SHA HEAD ada di remote.
+  const pushed = await verifyPushed(git, branchForPush);
+  if (!pushed.ok) {
+    return textResponse(
+      `❌ Commit dibuat, tetapi TIDAK ter-push.\n` +
+      `Repo: ${repoLabel()}\nBranch: ${branchForPush || "(tidak diketahui)"}\n` +
+      `Sebab: ${pushed.detail}\n\n` +
+      `Commit lokal: ${generatedSummary}\n\n` +
+      `Jalankan 'commit_and_push' lagi dengan 'branch' yang benar, atau push manual.`
+    );
+  }
+
   workflowState.state.commitAndPushCompleted = true;
   workflowState.state.lastCommitMessage = generatedSummary;
   workflowState.state.lastPushBranch = branchForPush;
@@ -159,8 +242,7 @@ export async function handleCommitAndPush(args, context) {
   await workflowState.save();
 
   return textResponse(
-    `✅ Commit and push completed!\nRepo: ${repoLabel()}\n\nCommit message: ${generatedSummary}\nPushed to: ${branchForPush || "(default upstream)"
-    }\n\nNext: Run 'perform_release' to handle the release and push tags.`
+    `✅ Commit and push completed!\nRepo: ${repoLabel()}\n\nCommit message: ${generatedSummary}\nPushed to: ${branchForPush} (verified at ${pushed.head.slice(0, 8)})\n\nNext: Run 'perform_release' to handle the release and push tags.`
   );
 }
 

package/workflow-state.js

@@ -33,6 +33,22 @@ let cachedUserStateDir = null;
  */
 const PROCESS_TOKEN = `proc-${process.pid}-${Math.random().toString(16).slice(2, 10)}`;
 
+/**
+ * Langkah workflow yang hanya boleh MAJU dalam satu task.
+ *
+ * Hanya flag PENCAPAIAN. Gerbang kualitas (`readyToCommit`,
+ * `readyCheckCompleted`, `commitAndPushCompleted`, `released`) SENGAJA tidak
+ * masuk: keempatnya direset ketika langkah sebelumnya diulang, dan memaksa
+ * nilainya tetap true akan melemahkan gerbang yang justru ingin ditegakkan.
+ */
+const MONOTONIC_STEP_FIELDS = [
+  "featureFlowCreated",
+  "bugFixed",
+  "testsCreated",
+  "testsPassed",
+  "documentationCreated",
+];
+
 function migrateOwnerMetadata(value) {
   if(value?.owner && !value.owner.processMarker && /^proc-[A-Za-z0-9-]+$/.test(value.owner.token || '')) {
     value.owner.processMarker=value.owner.token;
@@ -820,6 +836,44 @@ export class WorkflowState {
     return created;
   }
 
+  /**
+   * Gabungkan kemajuan langkah dari disk bila task-nya sama.
+   *
+   * Hanya menyentuh flag yang MONOTON dalam satu task. Field yang bisa turun
+   * dengan sengaja (mis. `readyCheckCompleted` yang direset `create_tests`)
+   * tidak digabung, karena itu bagian dari alur normal satu proses.
+   *
+   * `reconciled` sudah memuat state disk terbaru; `this.state` adalah milik
+   * proses ini. Kalau task berbeda atau disk idle, tidak ada yang digabung:
+   * itu task lain, atau task baru yang memang harus mulai dari nol.
+   */
+  mergeMonotonicProgress(reconciled) {
+    const diskTask = (reconciled?.diskTask || "").trim();
+    const ourTask = (this.state.taskDescription || "").trim();
+    if (!diskTask || !ourTask || diskTask !== ourTask) {
+      return;
+    }
+    if ((reconciled?.diskPhase || "idle") === "idle") {
+      return;
+    }
+
+    // Harus dari `reconciled` yang BARU dibaca. `lastReconcile` adalah hasil
+    // penyimpanan sebelumnya, sehingga bisa tertinggal satu putaran - dan
+    // justru itu yang membuat penggabungan gagal menangkap langkah terbaru.
+    const disk = reconciled?.diskState;
+    if (!disk) {
+      return;
+    }
+
+    // Kemajuan hanya boleh maju. Sekali sebuah langkah tercapai di proses mana
+    // pun, langkah itu tetap tercapai.
+    for (const field of MONOTONIC_STEP_FIELDS) {
+      if (disk[field] === true && this.state[field] !== true) {
+        this.state[field] = true;
+      }
+    }
+  }
+
   async save(options = {}) {
     assertSafeKnowledge(this.state);
     const reconciled = await this.reconcileWithDisk();
@@ -839,6 +893,19 @@ export class WorkflowState {
     }
     this.lastConflict = null;
 
+    // Dua proses MCP bisa melayani sesi yang SAMA (OpenCode men-spawn lebih dari
+    // satu instance), dan keduanya menulis berkas state yang sama. Tanpa ini,
+    // proses yang memegang state basi menimpa langkah yang sudah dicapai proses
+    // lain: `mark_bug_fixed` menjawab sukses, lalu `create_tests` menjawab
+    // "mark your feature/bug as fixed first". Gejalanya intermiten, sehingga
+    // mudah disalahkan pada hal lain.
+    //
+    // Langkah workflow bersifat monoton dalam satu task: sekali tercapai, tidak
+    // boleh mundur. Karena itu digabung dengan OR - tetapi HANYA bila task di
+    // disk memang task yang sama. `start_task` mengganti task, dan pada saat itu
+    // flag harus benar-benar direset, bukan dihidupkan kembali.
+    this.mergeMonotonicProgress(reconciled);
+
     this.state.owner = {
       processMarker: PROCESS_TOKEN,
       pid: process.pid,
@@ -988,11 +1055,15 @@ export class WorkflowState {
       foreignToken: null,
       diskTask: "",
       diskPhase: "idle",
+      // Dipakai mergeMonotonicProgress: state disk apa adanya, supaya flag
+      // langkah yang sudah dicapai proses lain bisa digabung.
+      diskState: null,
     };
     const disk = await this.readDiskState();
     if (!disk) {
       return result;
     }
+    result.diskState = disk;
 
     result.diskTask = disk.taskDescription || "";
     result.diskPhase = disk.currentPhase || "idle";