@renseiai/agentfactory 0.8.7 → 0.8.9

package/dist/src/governor/governor.js

@@ -11,6 +11,9 @@
 import { DEFAULT_GOVERNOR_CONFIG } from './governor-types.js';
 import { decideAction } from './decision-engine.js';
 import { WorkflowRegistry } from '../workflow/workflow-registry.js';
+import { ParallelismExecutor } from '../workflow/parallelism-executor.js';
+import { FanOutStrategy, FanInStrategy, RaceStrategy } from '../workflow/strategies/index.js';
+import { evaluateTransitions } from '../workflow/transition-engine.js';
 // ---------------------------------------------------------------------------
 // Logging
 // ---------------------------------------------------------------------------
@@ -41,15 +44,26 @@ export class WorkflowGovernor {
     deps;
     callbacks;
     workflowRegistry;
+    parallelismExecutor;
     intervalHandle = null;
     running = false;
     scanning = false;
-    constructor(config, deps, callbacks) {
+    constructor(config, deps, callbacks, parallelismExecutor) {
         const { workflow: workflowConfig, ...governorConfig } = config;
         this.config = { ...DEFAULT_GOVERNOR_CONFIG, ...governorConfig };
         this.deps = deps;
         this.callbacks = callbacks ?? {};
         this.workflowRegistry = WorkflowRegistry.create(workflowConfig);
+        // Use the provided executor or create a default one with all strategies registered
+        if (parallelismExecutor) {
+            this.parallelismExecutor = parallelismExecutor;
+        }
+        else {
+            this.parallelismExecutor = new ParallelismExecutor();
+            this.parallelismExecutor.registerStrategy('fan-out', new FanOutStrategy());
+            this.parallelismExecutor.registerStrategy('fan-in', new FanInStrategy());
+            this.parallelismExecutor.registerStrategy('race', new RaceStrategy());
+        }
     }
     // -------------------------------------------------------------------------
     // Lifecycle
@@ -207,6 +221,18 @@ export class WorkflowGovernor {
                 break;
             }
             try {
+                // Handle parallel group dispatch separately
+                if (item.action === 'trigger-parallel-group') {
+                    await this.handleParallelGroupDispatch(item.issue);
+                    result.actionsDispatched++;
+                    log.info('Dispatched parallel group action', {
+                        issueIdentifier: item.issue.identifier,
+                        action: item.action,
+                        reason: item.reason,
+                        priority: item.priority ?? 'none',
+                    });
+                    continue;
+                }
                 await this.deps.dispatchWork(item.issue, item.action);
                 result.actionsDispatched++;
                 log.info('Dispatched action', {
@@ -264,4 +290,89 @@ export class WorkflowGovernor {
         };
         return decideAction(ctx);
     }
+    /**
+     * Handle dispatching work for a parallel group.
+     *
+     * Fetches sub-issues for the parent, finds the applicable parallelism group,
+     * and executes the group using the ParallelismExecutor.
+     */
+    async handleParallelGroupDispatch(issue) {
+        if (!this.deps.getSubIssues) {
+            log.warn('getSubIssues dependency not provided, falling back to normal dispatch');
+            return;
+        }
+        const workflow = this.workflowRegistry.getWorkflow();
+        if (!workflow?.parallelism)
+            return;
+        const subIssues = await this.deps.getSubIssues(issue.id);
+        // Find the applicable parallelism group.
+        // Use the first group whose phases include a phase that can be
+        // resolved from the current workflow transitions.
+        const group = workflow.parallelism.find(g => g.phases.length > 0);
+        if (!group)
+            return;
+        const tasks = subIssues.map(sub => ({
+            id: sub.id,
+            issueId: sub.identifier,
+            phaseName: group.phases[0],
+        }));
+        const result = await this.parallelismExecutor.execute(group, tasks, async (task) => {
+            await this.deps.dispatchWork(subIssues.find(s => s.id === task.id), `trigger-${task.phaseName}`);
+            return {
+                id: task.id,
+                issueId: task.issueId,
+                success: true,
+            };
+        });
+        log.info('Parallel group dispatched', {
+            group: group.name,
+            strategy: group.strategy,
+            completed: result.completed.length,
+            failed: result.failed.length,
+            cancelled: result.cancelled.length,
+        });
+        // Propagate result to advance parent issue if group completed successfully
+        await this.handleParallelGroupCompletion(issue, result, group);
+    }
+    /**
+     * Handle post-parallel-group completion: if all tasks succeeded,
+     * evaluate transitions to advance the parent issue to the next phase.
+     */
+    async handleParallelGroupCompletion(parentIssue, result, group) {
+        // Only advance if the group completed with no failures
+        const allSucceeded = result.failed.length === 0 && result.completed.length > 0
+            && result.completed.every(t => t.success);
+        if (!allSucceeded) {
+            log.info('Parallel group has failures, not advancing parent', {
+                group: group.name,
+                failedCount: result.failed.length,
+            });
+            return;
+        }
+        // Evaluate the next transition for the parent issue.
+        // After a parallel development group completes, the parent
+        // should transition based on its next status mapping.
+        const nextPhaseResult = evaluateTransitions({
+            issue: { ...parentIssue, status: 'Finished' },
+            registry: this.workflowRegistry,
+            isParentIssue: true,
+        });
+        if (nextPhaseResult.action !== 'none') {
+            log.info('Advancing parent after parallel group completion', {
+                issueIdentifier: parentIssue.identifier,
+                nextAction: nextPhaseResult.action,
+                reason: nextPhaseResult.reason,
+            });
+            try {
+                await this.deps.dispatchWork(parentIssue, nextPhaseResult.action);
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : String(err);
+                log.error('Failed to advance parent after parallel group', {
+                    issueIdentifier: parentIssue.identifier,
+                    error: errorMsg,
+                });
+            }
+        }
+    }
 }

package/dist/src/governor/governor.test.js

@@ -512,3 +512,158 @@ describe('WorkflowGovernor.scanOnce — PRIORITY override sorting', () => {
         expect(dispatchWork.mock.calls[2][0]).toEqual(expect.objectContaining({ id: 'c' }));
     });
 });
+// ---------------------------------------------------------------------------
+// Parallel group dispatch
+// ---------------------------------------------------------------------------
+describe('WorkflowGovernor.scanOnce — parallel group dispatch', () => {
+    function makeWorkflowWithParallelism() {
+        return {
+            apiVersion: 'v1.1',
+            kind: 'WorkflowDefinition',
+            metadata: { name: 'test-parallel' },
+            phases: [
+                { name: 'development', template: 'development' },
+                { name: 'qa', template: 'qa' },
+            ],
+            transitions: [
+                { from: 'Backlog', to: 'development' },
+                { from: 'Finished', to: 'qa' },
+            ],
+            parallelism: [
+                {
+                    name: 'dev-parallel',
+                    phases: ['development'],
+                    strategy: 'fan-out',
+                },
+            ],
+        };
+    }
+    it('handles trigger-parallel-group by dispatching sub-issues', async () => {
+        const parentIssue = makeIssue({
+            id: 'parent-1',
+            identifier: 'SUP-100',
+            status: 'Backlog',
+        });
+        const subIssues = [
+            makeIssue({ id: 'sub-1', identifier: 'SUP-101', status: 'Backlog', parentId: 'parent-1' }),
+            makeIssue({ id: 'sub-2', identifier: 'SUP-102', status: 'Backlog', parentId: 'parent-1' }),
+        ];
+        const dispatchWork = vi.fn().mockResolvedValue(undefined);
+        const getSubIssues = vi.fn().mockResolvedValue(subIssues);
+        const deps = makeMockDeps({
+            listIssues: vi.fn().mockResolvedValue([parentIssue]),
+            isParentIssue: vi.fn().mockResolvedValue(true),
+            dispatchWork,
+            getSubIssues,
+        });
+        const governor = new WorkflowGovernor(makeConfig({
+            workflow: { workflow: makeWorkflowWithParallelism(), useBuiltinDefault: false },
+        }), deps);
+        const results = await governor.scanOnce();
+        expect(results[0].actionsDispatched).toBe(1);
+        expect(getSubIssues).toHaveBeenCalledWith('parent-1');
+        // dispatchWork is called for each sub-issue via the ParallelismExecutor,
+        // plus once more to advance the parent to the next phase (trigger-qa)
+        expect(dispatchWork).toHaveBeenCalledTimes(3);
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'sub-1' }), 'trigger-development');
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'sub-2' }), 'trigger-development');
+        // Parent advanced to QA after parallel group completion
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'parent-1' }), 'trigger-qa');
+    });
+    it('handles missing getSubIssues gracefully', async () => {
+        const parentIssue = makeIssue({
+            id: 'parent-1',
+            identifier: 'SUP-100',
+            status: 'Backlog',
+        });
+        const dispatchWork = vi.fn().mockResolvedValue(undefined);
+        const deps = makeMockDeps({
+            listIssues: vi.fn().mockResolvedValue([parentIssue]),
+            isParentIssue: vi.fn().mockResolvedValue(true),
+            dispatchWork,
+            // getSubIssues intentionally not provided
+        });
+        const governor = new WorkflowGovernor(makeConfig({
+            workflow: { workflow: makeWorkflowWithParallelism(), useBuiltinDefault: false },
+        }), deps);
+        const results = await governor.scanOnce();
+        // The action is counted as dispatched (the parallel group handler ran),
+        // but dispatchWork is NOT called for sub-issues since getSubIssues is missing
+        expect(results[0].actionsDispatched).toBe(1);
+        expect(dispatchWork).not.toHaveBeenCalled();
+    });
+    it('fan-in group completing advances parent to next phase', async () => {
+        const fanInWorkflow = {
+            apiVersion: 'v1.1',
+            kind: 'WorkflowDefinition',
+            metadata: { name: 'test-fan-in' },
+            phases: [
+                { name: 'development', template: 'development' },
+                { name: 'qa', template: 'qa' },
+            ],
+            transitions: [
+                { from: 'Backlog', to: 'development' },
+                { from: 'Finished', to: 'qa' },
+            ],
+            parallelism: [
+                {
+                    name: 'dev-fan-in',
+                    phases: ['development'],
+                    strategy: 'fan-in',
+                    waitForAll: true,
+                },
+            ],
+        };
+        const parentIssue = makeIssue({
+            id: 'parent-1',
+            identifier: 'SUP-200',
+            status: 'Backlog',
+        });
+        const subIssues = [
+            makeIssue({ id: 'sub-1', identifier: 'SUP-201', status: 'Backlog', parentId: 'parent-1' }),
+            makeIssue({ id: 'sub-2', identifier: 'SUP-202', status: 'Backlog', parentId: 'parent-1' }),
+            makeIssue({ id: 'sub-3', identifier: 'SUP-203', status: 'Backlog', parentId: 'parent-1' }),
+        ];
+        const dispatchWork = vi.fn().mockResolvedValue(undefined);
+        const getSubIssues = vi.fn().mockResolvedValue(subIssues);
+        const deps = makeMockDeps({
+            listIssues: vi.fn().mockResolvedValue([parentIssue]),
+            isParentIssue: vi.fn().mockResolvedValue(true),
+            dispatchWork,
+            getSubIssues,
+        });
+        const governor = new WorkflowGovernor(makeConfig({
+            workflow: { workflow: fanInWorkflow, useBuiltinDefault: false },
+        }), deps);
+        const results = await governor.scanOnce();
+        expect(results[0].actionsDispatched).toBe(1);
+        // All 3 sub-issues dispatched + 1 parent advancement to QA
+        expect(dispatchWork).toHaveBeenCalledTimes(4);
+        // Sub-issues dispatched for development
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'sub-1' }), 'trigger-development');
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'sub-2' }), 'trigger-development');
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'sub-3' }), 'trigger-development');
+        // Parent advanced to QA after all fan-in tasks completed
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'parent-1' }), 'trigger-qa');
+    });
+    it('non-parent issues with parallelism groups dispatch normally', async () => {
+        const issue = makeIssue({
+            id: 'issue-1',
+            identifier: 'SUP-100',
+            status: 'Backlog',
+        });
+        const dispatchWork = vi.fn().mockResolvedValue(undefined);
+        const deps = makeMockDeps({
+            listIssues: vi.fn().mockResolvedValue([issue]),
+            isParentIssue: vi.fn().mockResolvedValue(false),
+            dispatchWork,
+        });
+        const governor = new WorkflowGovernor(makeConfig({
+            workflow: { workflow: makeWorkflowWithParallelism(), useBuiltinDefault: false },
+        }), deps);
+        const results = await governor.scanOnce();
+        expect(results[0].actionsDispatched).toBe(1);
+        // Normal dispatch, not parallel
+        expect(dispatchWork).toHaveBeenCalledWith(expect.objectContaining({ id: 'issue-1' }), 'trigger-development');
+    });
+});

package/dist/src/index.d.ts

@@ -9,4 +9,5 @@ export * from './config/index.js';
 export * from './manifest/index.js';
 export * from './tools/index.js';
 export * from './workflow/index.js';
+export * from './routing/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA;AACpC,cAAc,aAAa,CAAA;AAC3B,cAAc,uBAAuB,CAAA;AACrC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,oBAAoB,CAAA"}

package/dist/src/index.js

@@ -9,3 +9,4 @@ export * from './config/index.js';
 export * from './manifest/index.js';
 export * from './tools/index.js';
 export * from './workflow/index.js';
+export * from './routing/index.js';

package/dist/src/merge-queue/adapters/github-native.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GitHub Native Merge Queue Adapter
+ *
+ * Implements MergeQueueAdapter for GitHub's built-in merge queue feature.
+ * Uses `gh api graphql` CLI for all GitHub API interactions.
+ */
+import type { MergeQueueAdapter, MergeQueueStatus } from '../types.js';
+export declare class GitHubNativeMergeQueueAdapter implements MergeQueueAdapter {
+    readonly name: "github-native";
+    canEnqueue(owner: string, repo: string, prNumber: number): Promise<boolean>;
+    enqueue(owner: string, repo: string, prNumber: number): Promise<MergeQueueStatus>;
+    getStatus(owner: string, repo: string, prNumber: number): Promise<MergeQueueStatus>;
+    dequeue(owner: string, repo: string, prNumber: number): Promise<void>;
+    isEnabled(owner: string, repo: string): Promise<boolean>;
+    /** Get the GraphQL node ID for a PR */
+    private getPRNodeId;
+    /** Execute a GraphQL query/mutation via gh CLI with retry */
+    private graphql;
+    /** Map GitHub merge queue entry to our MergeQueueStatus */
+    private mapEntryToStatus;
+}
+//# sourceMappingURL=github-native.d.ts.map

package/dist/src/merge-queue/adapters/github-native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-native.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/adapters/github-native.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAatE,qBAAa,6BAA8B,YAAW,iBAAiB;IACrE,QAAQ,CAAC,IAAI,EAAG,eAAe,CAAS;IAElC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA6C3E,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAwCjF,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA+FnF,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAmC9D,uCAAuC;YACzB,WAAW;IAiBzB,6DAA6D;YAC/C,OAAO;IAgCrB,2DAA2D;IAC3D,OAAO,CAAC,gBAAgB;CAgBzB"}

package/dist/src/merge-queue/adapters/github-native.js

@@ -0,0 +1,243 @@
+/**
+ * GitHub Native Merge Queue Adapter
+ *
+ * Implements MergeQueueAdapter for GitHub's built-in merge queue feature.
+ * Uses `gh api graphql` CLI for all GitHub API interactions.
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/** Timeout for GitHub API calls (30s) */
+const GH_API_TIMEOUT = 30000;
+/** Maximum retries for transient failures */
+const MAX_RETRIES = 2;
+/** Backoff delay between retries (ms) */
+const RETRY_DELAY = 1000;
+export class GitHubNativeMergeQueueAdapter {
+    name = 'github-native';
+    async canEnqueue(owner, repo, prNumber) {
+        try {
+            const query = `
+        query($owner: String!, $repo: String!, $prNumber: Int!) {
+          repository(owner: $owner, name: $repo) {
+            pullRequest(number: $prNumber) {
+              mergeable
+              reviewDecision
+              mergeQueueEntry { state }
+              baseRef {
+                branchProtectionRule {
+                  requiresStatusChecks
+                }
+              }
+            }
+          }
+        }
+      `;
+            const result = await this.graphql(query, { owner, repo, prNumber });
+            const pr = result.repository.pullRequest;
+            // Already in queue
+            if (pr.mergeQueueEntry)
+                return false;
+            // Must be mergeable
+            if (pr.mergeable !== 'MERGEABLE')
+                return false;
+            // Must be approved (if reviews are required)
+            if (pr.reviewDecision && pr.reviewDecision !== 'APPROVED')
+                return false;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async enqueue(owner, repo, prNumber) {
+        // First get the PR's node ID
+        const prId = await this.getPRNodeId(owner, repo, prNumber);
+        const mutation = `
+      mutation($prId: ID!) {
+        enqueuePullRequest(input: { pullRequestId: $prId }) {
+          mergeQueueEntry {
+            state
+            position
+            headCommit { oid }
+            enqueuedAt
+          }
+        }
+      }
+    `;
+        try {
+            const result = await this.graphql(mutation, { prId });
+            const entry = result.enqueuePullRequest.mergeQueueEntry;
+            return this.mapEntryToStatus(entry);
+        }
+        catch (error) {
+            return {
+                state: 'failed',
+                failureReason: error instanceof Error ? error.message : String(error),
+                checksStatus: [],
+            };
+        }
+    }
+    async getStatus(owner, repo, prNumber) {
+        const query = `
+      query($owner: String!, $repo: String!, $prNumber: Int!) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $prNumber) {
+            mergeQueueEntry {
+              state
+              position
+              headCommit { oid }
+              enqueuedAt
+            }
+            commits(last: 1) {
+              nodes {
+                commit {
+                  statusCheckRollup {
+                    contexts(first: 50) {
+                      nodes {
+                        ... on CheckRun {
+                          name
+                          conclusion
+                          status
+                        }
+                        ... on StatusContext {
+                          context
+                          state
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        const result = await this.graphql(query, { owner, repo, prNumber });
+        const pr = result.repository.pullRequest;
+        if (!pr.mergeQueueEntry) {
+            return { state: 'not-queued', checksStatus: [] };
+        }
+        const status = this.mapEntryToStatus(pr.mergeQueueEntry);
+        // Map check statuses
+        const commitNode = pr.commits.nodes[0];
+        if (commitNode?.commit.statusCheckRollup) {
+            status.checksStatus = commitNode.commit.statusCheckRollup.contexts.nodes.map((node) => {
+                if ('name' in node) {
+                    return {
+                        name: node.name,
+                        status: node.conclusion === 'SUCCESS' ? 'pass'
+                            : node.status === 'COMPLETED' ? 'fail'
+                                : 'pending',
+                    };
+                }
+                return {
+                    name: node.context,
+                    status: node.state === 'SUCCESS' ? 'pass'
+                        : node.state === 'PENDING' ? 'pending'
+                            : 'fail',
+                };
+            });
+        }
+        return status;
+    }
+    async dequeue(owner, repo, prNumber) {
+        const prId = await this.getPRNodeId(owner, repo, prNumber);
+        const mutation = `
+      mutation($prId: ID!) {
+        dequeuePullRequest(input: { pullRequestId: $prId }) {
+          mergeQueueEntry {
+            state
+          }
+        }
+      }
+    `;
+        await this.graphql(mutation, { prId });
+    }
+    async isEnabled(owner, repo) {
+        try {
+            const query = `
+        query($owner: String!, $repo: String!) {
+          repository(owner: $owner, name: $repo) {
+            defaultBranchRef {
+              branchProtectionRule {
+                requiresMergeQueue
+              }
+            }
+          }
+        }
+      `;
+            // Note: requiresMergeQueue might not be available in all GitHub API versions.
+            // Fallback: check if merge queue entries exist
+            const result = await this.graphql(query, { owner, repo });
+            return result.repository.defaultBranchRef?.branchProtectionRule?.requiresMergeQueue ?? false;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    /** Get the GraphQL node ID for a PR */
+    async getPRNodeId(owner, repo, prNumber) {
+        const query = `
+      query($owner: String!, $repo: String!, $prNumber: Int!) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $prNumber) {
+            id
+          }
+        }
+      }
+    `;
+        const result = await this.graphql(query, { owner, repo, prNumber });
+        return result.repository.pullRequest.id;
+    }
+    /** Execute a GraphQL query/mutation via gh CLI with retry */
+    async graphql(query, variables) {
+        const varsArgs = Object.entries(variables)
+            .map(([key, value]) => {
+            if (typeof value === 'number') {
+                return `-F ${key}=${value}`;
+            }
+            return `-f ${key}=${String(value)}`;
+        })
+            .join(' ');
+        const command = `gh api graphql -f query='${query.replace(/'/g, "'\\''")}' ${varsArgs}`;
+        let lastError = null;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                const { stdout } = await execAsync(command, { timeout: GH_API_TIMEOUT });
+                const response = JSON.parse(stdout);
+                if (response.errors?.length) {
+                    throw new Error(response.errors.map((e) => e.message).join('; '));
+                }
+                return response.data;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < MAX_RETRIES) {
+                    await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY * (attempt + 1)));
+                }
+            }
+        }
+        throw lastError;
+    }
+    /** Map GitHub merge queue entry to our MergeQueueStatus */
+    mapEntryToStatus(entry) {
+        const stateMap = {
+            QUEUED: 'queued',
+            AWAITING_CHECKS: 'queued',
+            MERGEABLE: 'merging',
+            MERGED: 'merged',
+            UNMERGEABLE: 'failed',
+            LOCKED: 'blocked',
+        };
+        return {
+            state: stateMap[entry.state] ?? 'not-queued',
+            position: entry.position,
+            checksStatus: [],
+        };
+    }
+}

package/dist/src/merge-queue/adapters/github-native.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=github-native.test.d.ts.map

package/dist/src/merge-queue/adapters/github-native.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-native.test.d.ts","sourceRoot":"","sources":["../../../../src/merge-queue/adapters/github-native.test.ts"],"names":[],"mappings":""}