ralph-hero-mcp-server 2.4.108 → 2.4.109

package/dist/lib/helpers.js

@@ -6,7 +6,8 @@
  * implementations to their original versions.
  */
 import { resolveProjectOwner } from "../types.js";
-import { WORKFLOW_STATE_TO_STATUS } from "./workflow-states.js";
+import { WORKFLOW_STATE_TO_STATUS, stateIndex } from "./workflow-states.js";
+import { buildBatchResolveQuery, buildBatchFieldValueQuery, } from "../tools/batch-tools.js";
 // ---------------------------------------------------------------------------
 // Helper: Fetch project data for field cache population
 // ---------------------------------------------------------------------------
@@ -338,4 +339,108 @@ export async function syncStatusField(client, fieldCache, projectItemId, workflo
         // Best-effort sync - don't fail the primary operation
     }
 }
+// ---------------------------------------------------------------------------
+// Helper: Extract Workflow State from batch field value response
+// ---------------------------------------------------------------------------
+export function extractWorkflowState(item) {
+    const node = item?.fieldValues?.nodes?.find((fv) => fv.field?.name === "Workflow State" &&
+        fv.__typename === "ProjectV2ItemFieldSingleSelectValue");
+    return node?.name ?? null;
+}
+// ---------------------------------------------------------------------------
+// Helper: Auto-advance parent when all siblings reach a gate state
+// ---------------------------------------------------------------------------
+/**
+ * Auto-advance the parent issue if all siblings have reached the same gate state.
+ * Uses batch queries for constant-time API cost (4-6 calls max regardless of sibling count).
+ * Best-effort: returns null on any failure without throwing.
+ */
+export async function autoAdvanceParent(client, fieldCache, owner, repo, issueNumber, gateState, projectNumber) {
+    try {
+        // Step A: Fetch parent number (1 query)
+        const parentResult = await client.query(`query($owner: String!, $repo: String!, $issueNum: Int!) {
+        repository(owner: $owner, name: $repo) {
+          issue(number: $issueNum) { parent { number } }
+        }
+      }`, { owner, repo, issueNum: issueNumber });
+        const parentNumber = parentResult.repository?.issue?.parent?.number;
+        if (!parentNumber)
+            return null;
+        // Step B: Fetch siblings (1 query)
+        const siblingResult = await client.query(`query($owner: String!, $repo: String!, $parentNum: Int!) {
+        repository(owner: $owner, name: $repo) {
+          issue(number: $parentNum) {
+            subIssues(first: 50) { nodes { number } }
+          }
+        }
+      }`, { owner, repo, parentNum: parentNumber });
+        const siblings = siblingResult.repository?.issue?.subIssues?.nodes || [];
+        if (siblings.length === 0)
+            return { advanced: false, parentNumber };
+        // Step C: Batch resolve project item IDs (1 query)
+        const allNumbers = [...siblings.map((s) => s.number), parentNumber];
+        const { queryString: resolveQueryString, variables: resolveVars } = buildBatchResolveQuery(owner, repo, allNumbers);
+        const resolveResult = await client.query(resolveQueryString, resolveVars);
+        // Parse resolved IDs and cache them
+        const projectId = fieldCache.getProjectId(projectNumber);
+        if (!projectId)
+            return null;
+        const projectItemIds = [];
+        for (let i = 0; i < allNumbers.length; i++) {
+            const entry = resolveResult[`i${i}`];
+            const issue = entry?.issue;
+            if (!issue) {
+                projectItemIds.push(null);
+                continue;
+            }
+            // Cache issue node ID
+            const issueCacheKey = `issue-node-id:${owner}/${repo}#${allNumbers[i]}`;
+            client.getCache().set(issueCacheKey, issue.id, 30 * 60 * 1000);
+            // Find matching project item
+            const projectItem = issue.projectItems?.nodes?.find((item) => item.project.id === projectId);
+            if (projectItem) {
+                const itemCacheKey = `project-item-id:${owner}/${repo}#${allNumbers[i]}`;
+                client.getCache().set(itemCacheKey, projectItem.id, 30 * 60 * 1000);
+                projectItemIds.push(projectItem.id);
+            }
+            else {
+                projectItemIds.push(null);
+            }
+        }
+        // All siblings + parent must have project item IDs
+        if (projectItemIds.some((id) => id === null)) {
+            return { advanced: false, parentNumber };
+        }
+        // Step D: Batch read field values (1 query)
+        const itemEntries = projectItemIds.map((id, i) => ({
+            alias: `fv${i}`,
+            itemId: id,
+        }));
+        const { queryString: fvQueryString, variables: fvVars } = buildBatchFieldValueQuery(itemEntries);
+        const fvResult = await client.query(fvQueryString, fvVars);
+        // Step E: Gate check (in-memory, zero cost)
+        const siblingCount = siblings.length;
+        const siblingStates = [];
+        for (let i = 0; i < siblingCount; i++) {
+            siblingStates.push(extractWorkflowState(fvResult[`fv${i}`]));
+        }
+        const allAtGate = siblingStates.every((state) => state === gateState);
+        if (!allAtGate)
+            return { advanced: false, parentNumber };
+        const parentIdx = allNumbers.length - 1;
+        const parentState = extractWorkflowState(fvResult[`fv${parentIdx}`]);
+        if (stateIndex(parentState || "") >= stateIndex(gateState)) {
+            return { advanced: false, parentNumber };
+        }
+        // Step F: Advance parent (1-2 mutations)
+        const parentItemId = projectItemIds[parentIdx];
+        await updateProjectItemField(client, fieldCache, parentItemId, "Workflow State", gateState, projectNumber);
+        await syncStatusField(client, fieldCache, parentItemId, gateState, projectNumber);
+        return { advanced: true, parentNumber, toState: gateState };
+    }
+    catch {
+        // Best-effort: don't fail the primary save_issue operation
+        return null;
+    }
+}
 //# sourceMappingURL=helpers.js.map

package/dist/lib/workflow-states.js

@@ -44,6 +44,7 @@ export const HUMAN_STATES = [
  */
 export const PARENT_GATE_STATES = [
     "Ready for Plan",
+    "Plan in Review",
     "In Review",
     "Done",
 ];

package/dist/tools/issue-tools.js

@@ -8,13 +8,13 @@ import { z } from "zod";
 import { paginateConnection } from "../lib/pagination.js";
 import { detectGroup } from "../lib/group-detection.js";
 import { detectPipelinePosition, OVERSIZED_ESTIMATES, } from "../lib/pipeline-detection.js";
-import { isValidState, VALID_STATES, LOCK_STATES, TERMINAL_STATES, WORKFLOW_STATE_TO_STATUS, } from "../lib/workflow-states.js";
+import { isValidState, isParentGateState, VALID_STATES, LOCK_STATES, TERMINAL_STATES, WORKFLOW_STATE_TO_STATUS, } from "../lib/workflow-states.js";
 import { buildBatchMutationQuery } from "./batch-tools.js";
 import { resolveState } from "../lib/state-resolution.js";
 import { parseDateMath } from "../lib/date-math.js";
 import { expandProfile } from "../lib/filter-profiles.js";
 import { toolSuccess, toolError } from "../types.js";
-import { ensureFieldCache, resolveIssueNodeId, resolveProjectItemId, updateProjectItemField, resolveConfig, resolveFullConfig, resolveFullConfigOptionalRepo, syncStatusField, } from "../lib/helpers.js";
+import { ensureFieldCache, resolveIssueNodeId, resolveProjectItemId, updateProjectItemField, resolveConfig, resolveFullConfig, resolveFullConfigOptionalRepo, syncStatusField, autoAdvanceParent, } from "../lib/helpers.js";
 // ---------------------------------------------------------------------------
 // Register issue tools
 // ---------------------------------------------------------------------------
@@ -997,6 +997,21 @@ export function registerIssueTools(server, client, fieldCache) {
                 }
               }`, { projectId, itemId: projectItemId, fieldId });
                 }
+                // 4f. Auto-advance parent if we just moved to a gate state
+                if (resolvedWorkflowState && isParentGateState(resolvedWorkflowState)) {
+                    try {
+                        const advanceResult = await autoAdvanceParent(client, fieldCache, owner, repo, args.number, resolvedWorkflowState, projectNumber);
+                        if (advanceResult?.advanced) {
+                            changes.parentAdvanced = {
+                                number: advanceResult.parentNumber,
+                                toState: advanceResult.toState,
+                            };
+                        }
+                    }
+                    catch {
+                        // Best-effort: don't fail the primary save_issue operation
+                    }
+                }
             }
             return toolSuccess({
                 number: args.number,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-hero-mcp-server",
-  "version": "2.4.108",
+  "version": "2.4.109",
   "description": "MCP server for GitHub Projects V2 - Ralph workflow automation",
   "type": "module",
   "main": "dist/index.js",