@xn-intenton-z2a/agentic-lib 7.1.14 → 7.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xn-intenton-z2a/agentic-lib",
-  "version": "7.1.14",
+  "version": "7.1.15",
   "description": "Agentic-lib Agentic Coding Systems SDK powering automated GitHub workflows.",
   "type": "module",
   "scripts": {

package/src/workflows/agent-supervisor.yml

@@ -3,7 +3,12 @@
 # .github/workflows/agent-supervisor.yml
 #
 # Reactive orchestration — triggers workflows based on telemetry.
-# When a build fails, dispatches fix-code. When issues pile up, dispatches review.
+# Watches all agentic workflows and takes corrective or follow-up actions:
+#   - Failed builds on PR branches → dispatch fix-code (with loop protection)
+#   - Successful merges → dispatch transform to pick up next issue
+#   - Discussion bot actions → dispatch maintain or transform as follow-up
+#   - Stale issues → dispatch review
+#   - Stale conflicting PRs → remove automerge label
 
 name: agent-supervisor
 run-name: "agent-supervisor [${{ github.ref_name }}]"
@@ -14,6 +19,10 @@ on:
       - test
       - agent-flow-transform
       - agent-flow-maintain
+      - agent-flow-fix-code
+      - agent-flow-review
+      - agent-discussions-bot
+      - ci-automerge
     types:
       - completed
   workflow_dispatch:
@@ -22,8 +31,14 @@ permissions:
   actions: write
   contents: read
   issues: read
+  pull-requests: write
   checks: read
 
+env:
+  maxFixAttempts: "3"
+  staleDays: "14"
+  stalePrDays: "3"
+
 jobs:
   evaluate:
     runs-on: ubuntu-latest
@@ -32,54 +47,173 @@ jobs:
         uses: actions/github-script@v7
         with:
           script: |
+            const owner = context.repo.owner;
+            const repo = context.repo.repo;
             const workflowRun = context.payload.workflow_run;
+            const workflowName = workflowRun?.name || '';
+            const conclusion = workflowRun?.conclusion || '';
+            const branch = workflowRun?.head_branch || '';
+            const isAgenticBranch = branch && !['main', 'master'].includes(branch);
+            const maxFixAttempts = parseInt(process.env.maxFixAttempts) || 3;
+            const staleDays = parseInt(process.env.staleDays) || 14;
+            const stalePrDays = parseInt(process.env.stalePrDays) || 3;
 
-            // If a workflow failed, trigger fix-code
-            if (workflowRun && workflowRun.conclusion === 'failure') {
-              const branch = workflowRun.head_branch;
-              const isAgenticBranch = !['main', 'master'].includes(branch);
+            core.info(`Supervisor: workflow="${workflowName}" conclusion="${conclusion}" branch="${branch}"`);
 
-              if (isAgenticBranch) {
-                core.info(`Workflow "${workflowRun.name}" failed on branch ${branch}. Dispatching fix-code.`);
+            // ─── 1. Failure on PR branch → dispatch fix-code (with loop protection) ───
 
-                // Find the PR for this branch
+            try {
+              if (workflowRun && conclusion === 'failure' && isAgenticBranch) {
                 const { data: prs } = await github.rest.pulls.list({
-                  ...context.repo,
-                  state: 'open',
-                  head: `${context.repo.owner}:${branch}`,
+                  owner, repo, state: 'open',
+                  head: `${owner}:${branch}`,
                   per_page: 1,
                 });
 
                 if (prs.length > 0) {
-                  await github.rest.actions.createWorkflowDispatch({
-                    ...context.repo,
+                  const pr = prs[0];
+                  const prNumber = pr.number;
+
+                  // Count prior fix-code runs for this branch to prevent infinite loops
+                  const { data: fixRuns } = await github.rest.actions.listWorkflowRuns({
+                    owner, repo,
                     workflow_id: 'agent-flow-fix-code.yml',
-                    ref: context.ref,
-                    inputs: { 'pr-number': String(prs[0].number) },
+                    branch,
+                    per_page: maxFixAttempts + 1,
                   });
-                  core.info(`Dispatched fix-code for PR #${prs[0].number}`);
+                  const fixCount = fixRuns.total_count;
+
+                  if (fixCount >= maxFixAttempts) {
+                    core.info(`PR #${prNumber} has had ${fixCount} fix attempts (limit: ${maxFixAttempts}). Removing automerge label.`);
+                    try {
+                      await github.rest.issues.removeLabel({
+                        owner, repo, issue_number: prNumber, name: 'automerge',
+                      });
+                    } catch (e) { /* label may not exist */ }
+                    await github.rest.issues.createComment({
+                      owner, repo, issue_number: prNumber,
+                      body: `Supervisor: ${fixCount} fix-code attempts have failed. Removing automerge label — manual intervention needed.`,
+                    });
+                  } else {
+                    core.info(`Dispatching fix-code for PR #${prNumber} (attempt ${fixCount + 1}/${maxFixAttempts}).`);
+                    await github.rest.actions.createWorkflowDispatch({
+                      owner, repo,
+                      workflow_id: 'agent-flow-fix-code.yml',
+                      ref: 'main',
+                      inputs: { 'pr-number': String(prNumber) },
+                    });
+                  }
+                }
+              }
+            } catch (err) {
+              core.warning(`Fix-code dispatch failed: ${err.message}`);
+            }
+
+            // ─── 2. Successful merge → dispatch transform for next issue ──────────
+
+            try {
+              if (workflowName === 'ci-automerge' && conclusion === 'success') {
+                core.info('Automerge succeeded. Dispatching transform to pick up next issue.');
+                await github.rest.actions.createWorkflowDispatch({
+                  owner, repo,
+                  workflow_id: 'agent-flow-transform.yml',
+                  ref: 'main',
+                });
+              }
+            } catch (err) {
+              core.warning(`Post-merge transform dispatch failed: ${err.message}`);
+            }
+
+            // ─── 3. Discussion bot follow-through ─────────────────────────────────
+
+            try {
+              if (workflowName === 'agent-discussions-bot' && conclusion === 'success') {
+                // Check the most recent run's jobs for the outcome
+                const runId = workflowRun.id;
+                const { data: jobs } = await github.rest.actions.listJobsForWorkflowRun({
+                  owner, repo, run_id: runId,
+                });
+                const respondJob = jobs.jobs.find(j => j.name === 'respond');
+                if (respondJob) {
+                  // Look through step names/outputs for action indicators
+                  const steps = respondJob.steps || [];
+                  const agenticStep = steps.find(s => s.name === 'Respond to discussion');
+                  if (agenticStep && agenticStep.conclusion === 'success') {
+                    core.info('Discussion bot completed. Dispatching maintain to pick up any new features.');
+                    await github.rest.actions.createWorkflowDispatch({
+                      owner, repo,
+                      workflow_id: 'agent-flow-maintain.yml',
+                      ref: 'main',
+                    });
+                  }
                 }
               }
+            } catch (err) {
+              core.warning(`Discussion bot follow-through failed: ${err.message}`);
             }
 
-            // Check for stale issues (open > 14 days with no activity)
-            const { data: issues } = await github.rest.issues.listForRepo({
-              ...context.repo,
-              state: 'open',
-              labels: 'automated',
-              sort: 'updated',
-              direction: 'asc',
-              per_page: 5,
-            });
-
-            const fourteenDaysAgo = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000);
-            const staleIssues = issues.filter(i => new Date(i.updated_at) < fourteenDaysAgo);
-
-            if (staleIssues.length > 0) {
-              core.info(`Found ${staleIssues.length} stale issue(s). Dispatching review.`);
-              await github.rest.actions.createWorkflowDispatch({
-                ...context.repo,
-                workflow_id: 'agent-flow-review.yml',
-                ref: context.ref,
+            // ─── 4. Stale issues → dispatch review ────────────────────────────────
+
+            try {
+              const { data: issues } = await github.rest.issues.listForRepo({
+                owner, repo, state: 'open',
+                labels: 'automated',
+                sort: 'updated',
+                direction: 'asc',
+                per_page: 5,
               });
+
+              const cutoff = new Date(Date.now() - staleDays * 24 * 60 * 60 * 1000);
+              const staleIssues = issues.filter(i => new Date(i.updated_at) < cutoff);
+
+              if (staleIssues.length > 0) {
+                core.info(`Found ${staleIssues.length} stale issue(s). Dispatching review.`);
+                await github.rest.actions.createWorkflowDispatch({
+                  owner, repo,
+                  workflow_id: 'agent-flow-review.yml',
+                  ref: 'main',
+                });
+              }
+            } catch (err) {
+              core.warning(`Stale issue check failed: ${err.message}`);
+            }
+
+            // ─── 5. Stale conflicting PRs → remove automerge label ────────────────
+
+            try {
+              const { data: openPRs } = await github.rest.pulls.list({
+                owner, repo, state: 'open',
+                sort: 'updated',
+                direction: 'asc',
+                per_page: 10,
+              });
+
+              const prCutoff = new Date(Date.now() - stalePrDays * 24 * 60 * 60 * 1000);
+              for (const pr of openPRs) {
+                const hasAutomerge = pr.labels.some(l => l.name === 'automerge');
+                if (!hasAutomerge) continue;
+
+                const isStale = new Date(pr.updated_at) < prCutoff;
+                if (!isStale) continue;
+
+                // Fetch full PR to get mergeable_state
+                const { data: fullPr } = await github.rest.pulls.get({
+                  owner, repo, pull_number: pr.number,
+                });
+
+                if (fullPr.mergeable_state === 'dirty' || fullPr.mergeable === false) {
+                  core.info(`PR #${pr.number} has conflicts and is stale (${stalePrDays}+ days). Removing automerge label.`);
+                  try {
+                    await github.rest.issues.removeLabel({
+                      owner, repo, issue_number: pr.number, name: 'automerge',
+                    });
+                  } catch (e) { /* label may not exist */ }
+                  await github.rest.issues.createComment({
+                    owner, repo, issue_number: pr.number,
+                    body: `Supervisor: this PR has had conflicts for ${stalePrDays}+ days. Removing automerge label — resolve conflicts and re-add to retry.`,
+                  });
+                }
+              }
+            } catch (err) {
+              core.warning(`Stale PR check failed: ${err.message}`);
             }

package/src/workflows/ci-automerge.yml

@@ -356,18 +356,18 @@ jobs:
               message = `Branch '${pullRequest.head.ref}' deleted.`;
               prMerged = 'true';
             } else if (pullRequest.mergeable_state === 'dirty' || pullRequest.mergeable === false) {
-              message = `PR #${pullNumber} has conflicts. Closing.`;
+              message = `PR #${pullNumber} has conflicts. Removing automerge label.`;
+              try {
+                await github.rest.issues.removeLabel({
+                  owner, repo, issue_number: pullNumber, name: 'automerge',
+                });
+              } catch (e) {
+                core.info(`Could not remove automerge label: ${e.message}`);
+              }
               await github.rest.issues.createComment({
                 owner, repo, issue_number: pullNumber,
-                body: `This pull request is being closed due to conflicts (mergeable_state: ${pullRequest.mergeable_state}, mergeable: ${pullRequest.mergeable}).`,
+                body: `Automerge label removed — this PR has conflicts (mergeable_state: ${pullRequest.mergeable_state}). Resolve conflicts and re-add the label to retry.`,
               });
-              await github.rest.pulls.update({ owner, repo, pull_number: pullNumber, state: "closed" });
-              try {
-                await github.rest.git.deleteRef({ owner, repo, ref: `heads/${pullRequest.head.ref}` });
-                message += ` Branch '${pullRequest.head.ref}' deleted.`;
-              } catch (error) {
-                message += ` Failed to delete branch: ${error.message}`;
-              }
               prMerged = 'false';
             } else if (pullRequest.mergeable_state === 'unstable') {
               message = `PR #${pullNumber} checks still running (mergeable_state: unstable). Will retry when test workflow completes.`;