forge-workflow 0.1.0-beta.3 → 0.1.0-beta.5

package/lib/pr-monitor/upsert-sticky.js

@@ -1,169 +0,0 @@
-'use strict';
-
-/**
- * PR-monitor sticky-comment upsert — race-safe, converges to EXACTLY ONE sticky
- * comment per PR even under a concurrent burst of workflow runs.
- *
- * Why this exists: the pr-monitor workflow deliberately has NO `concurrency:`
- * group. A per-PR group does not help — GitHub's queue replacement cancels the
- * previously-PENDING run in a group UNCONDITIONALLY (independent of
- * cancel-in-progress), and this workflow's triggers (check_suite:completed fires
- * ~10+ times per push, plus reviews/comments) burst hard, so a group left a trail
- * of CANCELLED runs that render as red/non-SUCCESS checks and tripped merge-gate
- * tooling (kernel issue 97e6a146). Dropping the group removes the cancellations,
- * but then two concurrent first-runs on a PR with no sticky yet would BOTH find
- * nothing and BOTH create one → duplicate sticky comments. This module closes
- * that race deterministically instead.
- *
- * Reconcile-to-one algorithm:
- *   1. List marker comments. If none, create one, then RE-LIST (a concurrent run
- *      may have created its own in the same burst).
- *   2. Pick the deterministic survivor: the LOWEST comment id (oldest). Every
- *      concurrent run picks the SAME survivor, so they never fight.
- *   3. Update the survivor with the latest body; delete every other marker
- *      comment. Deletes are idempotent (a 404 means a peer already removed it).
- *
- * A create that lands AFTER a run's re-list is self-healed by the next event:
- * every run reconciles to one, and events keep arriving, so the PR converges to a
- * single sticky comment.
- *
- * @module pr-monitor/upsert-sticky
- */
-
-const { execFileSync } = require('node:child_process');
-
-/** Ids of comments whose body carries the sticky marker. */
-function markerCommentIds(comments, marker) {
-  return (Array.isArray(comments) ? comments : [])
-    .filter((comment) => typeof comment.body === 'string' && comment.body.includes(marker))
-    .map((comment) => comment.id);
-}
-
-/** Ascending by numeric id, so the survivor (index 0) is the oldest comment. */
-function sortIdsAscending(ids) {
-  return [...ids].sort((left, right) => Number(left) - Number(right));
-}
-
-/**
- * Drive a client to exactly one sticky comment. `client` abstracts the GitHub
- * calls so the reconcile logic is unit-testable without the network:
- *   - list()        → array of { id, body }
- *   - create()      → create a new sticky comment (body supplied by the client)
- *   - update(id)    → overwrite comment `id` with the latest body
- *   - remove(id)    → delete comment `id` (must tolerate an already-deleted 404)
- *
- * @returns {Promise<{ survivor: (number|string|null), deleted: Array<number|string> }>}
- */
-async function upsertStickyComment({ marker }, client) {
-  let ids = markerCommentIds(await client.list(), marker);
-
-  if (ids.length === 0) {
-    await client.create();
-    // Re-list: a concurrent run may have created its own sticky in this burst.
-    ids = markerCommentIds(await client.list(), marker);
-  }
-
-  if (ids.length === 0) {
-    // The just-created comment is not visible yet (eventual consistency); its
-    // body is already correct, and the next event will reconcile if a peer raced.
-    return { survivor: null, deleted: [] };
-  }
-
-  ids = sortIdsAscending(ids);
-  const survivor = ids[0];
-  await client.update(survivor);
-
-  const deleted = [];
-  for (const id of ids.slice(1)) {
-    await client.remove(id);
-    deleted.push(id);
-  }
-
-  return { survivor, deleted };
-}
-
-// Single choke point for the `gh` CLI, matching lib/commands/merge.js. `gh` is a
-// hardcoded literal (never user input) and args are an array (no shell), so the
-// S4036 PATH-search finding is a false positive in this developer-tool context;
-// one annotation here covers every call site. `encoding: 'utf8'` also pipes
-// stderr onto the thrown error, so isAlreadyGone() below can classify failures.
-function runGh(args) {
-  return execFileSync('gh', args, { encoding: 'utf8' }); // NOSONAR S4036 - hardcoded CLI (gh), args array (no shell), developer-tool context
-}
-
-/**
- * True only when a `gh api` failure means the target comment is already absent
- * (HTTP 404 / 410) — the benign "a peer got there first" case. Auth failures,
- * rate limits (403), and every other error return false so they propagate and
- * surface a diagnostic instead of silently breaking the exactly-one invariant.
- */
-function isAlreadyGone(error) {
-  const text = `${error && error.stderr ? error.stderr : ''} ${error && error.message ? error.message : ''}`;
-  return /HTTP 404|HTTP 410|\bNot Found\b|\bGone\b/i.test(text);
-}
-
-/**
- * GitHub-backed client (shells to `gh api`, like lib/pr-monitor/gather.js). The
- * reconcile logic above is unit-tested; the error-tolerance in update/remove is
- * too, via an injectable `run`. create/update both send the same pre-rendered
- * payload file the render step wrote, so the body is identical.
- */
-function ghStickyClient({ repo, pr, payloadFile, run = runGh }) {
-  return {
-    async list() {
-      const out = run(['api', `repos/${repo}/issues/${pr}/comments`, '--paginate']);
-      return out && out.trim() ? JSON.parse(out) : [];
-    },
-    async create() {
-      run(['api', '-X', 'POST', `repos/${repo}/issues/${pr}/comments`, '--input', payloadFile]);
-    },
-    async update(id) {
-      try {
-        run(['api', '-X', 'PATCH', `repos/${repo}/issues/comments/${id}`, '--input', payloadFile]);
-      } catch (error) {
-        if (!isAlreadyGone(error)) {
-          throw error;
-        }
-        // Our chosen survivor was deleted by a peer whose survivor had a lower id:
-        // the peer's sticky wins, exactly-one still holds, so we are done.
-      }
-    },
-    async remove(id) {
-      try {
-        run(['api', '-X', 'DELETE', `repos/${repo}/issues/comments/${id}`]);
-      } catch (error) {
-        if (!isAlreadyGone(error)) {
-          throw error;
-        }
-        // Already gone (a concurrent run deleted it first) — the goal state holds.
-      }
-    },
-  };
-}
-
-async function main() {
-  const repo = process.env.GH_REPO;
-  const pr = process.env.PR;
-  const payloadFile = process.env.STICKY_PAYLOAD_FILE || 'monitor-payload.json';
-  const { STICKY_MARKER } = require('./render-sticky');
-
-  const client = ghStickyClient({ repo, pr, payloadFile });
-  const { survivor, deleted } = await upsertStickyComment({ marker: STICKY_MARKER }, client);
-  const survivorLabel = survivor === null ? 'created (not yet visible)' : survivor;
-  console.log(`Sticky comment reconciled to one: survivor=${survivorLabel}, deleted=${deleted.length}`);
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    console.error(error.message);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  upsertStickyComment,
-  markerCommentIds,
-  sortIdsAscending,
-  isAlreadyGone,
-  ghStickyClient,
-};

package/lib/status/beads-snapshot.js

@@ -1,145 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { secureExecFileSync } = require('../shell-utils.js');
-
-function getGitConfig(projectRoot, key) {
-	try {
-		return secureExecFileSync('git', ['config', key], {
-			encoding: 'utf8',
-			cwd: projectRoot,
-			stdio: ['pipe', 'pipe', 'pipe'],
-		}).trim();
-	} catch (_error) {
-		return '';
-	}
-}
-
-function getDeveloperIdentity(projectRoot) {
-	return {
-		email: getGitConfig(projectRoot, 'user.email'),
-		name: getGitConfig(projectRoot, 'user.name'),
-	};
-}
-
-function normalizeEmail(value) {
-	return typeof value === 'string' ? value.trim().toLowerCase() : '';
-}
-
-function readIssues(projectRoot) {
-	const issuesPath = path.join(projectRoot, '.beads', 'issues.jsonl');
-	if (!fs.existsSync(issuesPath)) {
-		return [];
-	}
-
-	const raw = fs.readFileSync(issuesPath, 'utf8');
-	const latestById = new Map();
-
-	for (const line of raw.split(/\r?\n/)) {
-		if (!line.trim()) {
-			continue;
-		}
-
-		try {
-			const issue = JSON.parse(line);
-			if (issue && issue.id) {
-				latestById.set(issue.id, issue);
-			}
-		} catch (_error) {
-			// Ignore malformed rows so one bad append does not break status.
-		}
-	}
-
-	return Array.from(latestById.values());
-}
-
-function isAssignedToDeveloper(issue, developer) {
-	if (!issue || !developer) {
-		return false;
-	}
-
-	if (issue.owner) {
-		const developerEmail = normalizeEmail(developer.email);
-		return developerEmail !== '' && normalizeEmail(issue.owner) === developerEmail;
-	}
-
-	return developer.name !== '' && issue.created_by === developer.name;
-}
-
-const DEFAULT_STALE_AFTER_DAYS = 14;
-
-function parseTimestampOrZero(value) {
-	if (!value) {
-		return 0;
-	}
-
-	const parsed = Date.parse(value);
-	return Number.isNaN(parsed) ? 0 : parsed;
-}
-
-function sortByUpdatedAtDesc(left, right) {
-	const leftTime = parseTimestampOrZero(left.updated_at);
-	const rightTime = parseTimestampOrZero(right.updated_at);
-	return rightTime - leftTime;
-}
-
-function hasUnresolvedDependencies(issue) {
-	return Number(issue.dependency_count || 0) > 0;
-}
-
-function isOpenIssue(issue) {
-	return issue.status === 'open' || issue.status === 'in_progress';
-}
-
-function isStale(issue, now, staleAfterDays) {
-	if (!isOpenIssue(issue)) {
-		return false;
-	}
-
-	const updatedAt = parseTimestampOrZero(issue.updated_at);
-	if (updatedAt === 0) {
-		return false;
-	}
-
-	const staleMs = staleAfterDays * 24 * 60 * 60 * 1000;
-	return now.getTime() - updatedAt >= staleMs;
-}
-
-function readBeadsSnapshot(projectRoot, options = {}) {
-	const developer = getDeveloperIdentity(projectRoot);
-	const issues = readIssues(projectRoot);
-	const parsedNow = options.now instanceof Date
-		? options.now
-		: (typeof options.now === 'string' ? new Date(options.now) : null);
-	const now = parsedNow instanceof Date && !Number.isNaN(parsedNow.getTime())
-		? parsedNow
-		: new Date();
-	const parsedStaleAfterDays = Number(options.staleAfterDays);
-	const staleAfterDays = Number.isFinite(parsedStaleAfterDays)
-		? parsedStaleAfterDays
-		: DEFAULT_STALE_AFTER_DAYS;
-
-	return {
-		developer,
-		issues,
-		active: issues.filter(issue => issue.status === 'in_progress').sort(sortByUpdatedAtDesc),
-		activeAssigned: issues.filter(issue => issue.status === 'in_progress' && isAssignedToDeveloper(issue, developer)),
-		ready: issues.filter(issue => issue.status === 'open' && !hasUnresolvedDependencies(issue)),
-		blocked: issues.filter(issue => isOpenIssue(issue) && hasUnresolvedDependencies(issue)).sort(sortByUpdatedAtDesc),
-		stale: issues.filter(issue => isStale(issue, now, staleAfterDays)).sort(sortByUpdatedAtDesc),
-		recentCompleted: issues.filter(issue => issue.status === 'closed').sort(sortByUpdatedAtDesc),
-		limits: [
-			'Uses local Beads issues.jsonl only.',
-			'Does not read GitHub review, CI, project, or sync freshness state.',
-		],
-	};
-}
-
-module.exports = {
-	getDeveloperIdentity,
-	isAssignedToDeveloper,
-	readBeadsSnapshot,
-	hasUnresolvedDependencies,
-	isStale,
-};