@dev-loops/core 0.1.0

package/src/loop/copilot-ci-status.mjs

@@ -0,0 +1,255 @@
+const VALID_HEAD_SCOPED_CI_STATUSES = new Set(["success", "failure", "pending", "none"]);
+const FAILURE_CONCLUSIONS = new Set(["FAILURE", "ACTION_REQUIRED", "TIMED_OUT", "STARTUP_FAILURE"]);
+const SUCCESS_CONCLUSIONS = new Set(["SUCCESS", "NEUTRAL", "SKIPPED"]);
+const STATUS_CONTEXT_FAILURE_STATES = new Set(["FAILURE", "ERROR"]);
+const STATUS_CONTEXT_PENDING_STATES = new Set(["PENDING", "EXPECTED"]);
+const STATUS_CONTEXT_SUCCESS_STATES = new Set(["SUCCESS"]);
+
+function normalizeHeadScopedCiStatus(status) {
+  return VALID_HEAD_SCOPED_CI_STATUSES.has(status) ? status : "none";
+}
+
+function buildCiContract(overallStatus) {
+  const isWaiting = overallStatus === "pending" || overallStatus === "none";
+
+  return {
+    overallStatus,
+    rollup: {
+      success: overallStatus === "success",
+      pending: overallStatus === "pending",
+      failure: overallStatus === "failure",
+      none: overallStatus === "none",
+    },
+    semantics: {
+      wait: isWaiting,
+      blocked: overallStatus === "failure",
+      timeoutDisposition: isWaiting ? "remain_waiting" : "not_applicable",
+    },
+  };
+}
+
+/**
+ * Normalize the PR `statusCheckRollup` payload into a stable status.
+ * Supports both CheckRun-style entries (`status` + `conclusion`) and legacy
+ * StatusContext-style entries (`state`).
+ *
+ * @param {Array<object>} rollup
+ * @returns {"success"|"failure"|"pending"|"none"}
+ */
+export function normalizeStatusCheckRollupStatus(rollup) {
+  if (!Array.isArray(rollup) || rollup.length === 0) {
+    return "none";
+  }
+
+  let hasPending = false;
+  let hasFailure = false;
+  let hasSuccess = false;
+  let hasUnsupportedCompleted = false;
+
+  for (const check of rollup) {
+    const state = typeof check?.state === "string" ? check.state.toUpperCase() : "";
+    if (STATUS_CONTEXT_FAILURE_STATES.has(state)) {
+      hasFailure = true;
+      continue;
+    }
+    if (STATUS_CONTEXT_PENDING_STATES.has(state)) {
+      hasPending = true;
+      continue;
+    }
+    if (STATUS_CONTEXT_SUCCESS_STATES.has(state)) {
+      hasSuccess = true;
+      continue;
+    }
+
+    const status = typeof check?.status === "string" ? check.status.toUpperCase() : "";
+    const conclusion = typeof check?.conclusion === "string" ? check.conclusion.toUpperCase() : "";
+
+    if (status === "COMPLETED" && FAILURE_CONCLUSIONS.has(conclusion)) {
+      hasFailure = true;
+      continue;
+    }
+
+    if (status !== "COMPLETED") {
+      hasPending = true;
+      continue;
+    }
+
+    if (SUCCESS_CONCLUSIONS.has(conclusion)) {
+      hasSuccess = true;
+      continue;
+    }
+
+    hasUnsupportedCompleted = true;
+  }
+
+  if (hasFailure) return "failure";
+  if (hasPending) return "pending";
+  if (hasUnsupportedCompleted) return "none";
+  if (hasSuccess) return "success";
+  return "none";
+}
+
+/**
+ * Summarize the GitHub check-runs API payload for one head SHA.
+ *
+ * @param {object} payload
+ * @returns {{ status: "success"|"failure"|"pending"|"none", unsupportedCompleted: boolean, failureDetails?: Array<string> }}
+ */
+export function summarizeHeadScopedCheckRunsSignal(payload) {
+  const runs = Array.isArray(payload?.check_runs) ? payload.check_runs : [];
+  if (runs.length === 0) {
+    return { status: "none", unsupportedCompleted: false };
+  }
+
+  let hasPending = false;
+  let hasFailure = false;
+  let hasSuccess = false;
+  let hasUnsupportedCompleted = false;
+  const failureDetails = [];
+
+  for (const run of runs) {
+    const status = typeof run?.status === "string" ? run.status.toUpperCase() : "";
+    const conclusion = typeof run?.conclusion === "string" ? run.conclusion.toUpperCase() : "";
+
+    if (status !== "COMPLETED") {
+      hasPending = true;
+      continue;
+    }
+
+    if (FAILURE_CONCLUSIONS.has(conclusion)) {
+      hasFailure = true;
+      const name = typeof run?.name === "string" ? run.name : "";
+      if (name) failureDetails.push(name);
+      continue;
+    }
+
+    if (SUCCESS_CONCLUSIONS.has(conclusion)) {
+      hasSuccess = true;
+      continue;
+    }
+
+    hasUnsupportedCompleted = true;
+  }
+
+  if (hasFailure) return { status: "failure", unsupportedCompleted: hasUnsupportedCompleted, failureDetails };
+  if (hasPending) return { status: "pending", unsupportedCompleted: hasUnsupportedCompleted, failureDetails: failureDetails.length > 0 ? failureDetails : undefined };
+  if (hasUnsupportedCompleted) return { status: "none", unsupportedCompleted: true, failureDetails: failureDetails.length > 0 ? failureDetails : undefined };
+  if (hasSuccess) return { status: "success", unsupportedCompleted: false, failureDetails: failureDetails.length > 0 ? failureDetails : undefined };
+  return { status: "none", unsupportedCompleted: false, failureDetails: failureDetails.length > 0 ? failureDetails : undefined };
+}
+
+/**
+ * Normalize the GitHub check-runs API payload for one head SHA into a stable status.
+ *
+ * @param {object} payload
+ * @returns {"success"|"failure"|"pending"|"none"}
+ */
+export function normalizeHeadScopedCheckRunsStatus(payload) {
+  return summarizeHeadScopedCheckRunsSignal(payload).status;
+}
+
+/**
+ * Normalize the GitHub commit-status API payload for one head SHA into a stable status.
+ *
+ * @param {object} payload
+ * @returns {"success"|"failure"|"pending"|"none"}
+ */
+export function normalizeHeadScopedCommitStatus(payload) {
+  const statuses = Array.isArray(payload?.statuses) ? payload.statuses : [];
+  if (statuses.length === 0) {
+    return "none";
+  }
+
+  let hasPending = false;
+  let hasFailure = false;
+  let hasSuccess = false;
+
+  for (const statusItem of statuses) {
+    const state = typeof statusItem?.state === "string" ? statusItem.state.toLowerCase() : "";
+    if (state === "pending") {
+      hasPending = true;
+      continue;
+    }
+    if (state === "failure" || state === "error") {
+      hasFailure = true;
+      continue;
+    }
+    if (state === "success") {
+      hasSuccess = true;
+      continue;
+    }
+  }
+
+  if (hasFailure) return "failure";
+  if (hasPending) return "pending";
+  if (hasSuccess) return "success";
+  return "none";
+}
+
+/**
+ * Merge head-scoped check-runs + commit-status signals into one deterministic status.
+ *
+ * @param {"success"|"failure"|"pending"|"none"} checkRunsStatus
+ * @param {"success"|"failure"|"pending"|"none"} commitStatus
+ * @returns {"success"|"failure"|"pending"|"none"}
+ */
+export function mergeHeadScopedCiStatuses(checkRunsStatus, commitStatus) {
+  const normalizedCheckRunsStatus = normalizeHeadScopedCiStatus(checkRunsStatus);
+  const normalizedCommitStatus = normalizeHeadScopedCiStatus(commitStatus);
+
+  if (normalizedCheckRunsStatus === "failure" || normalizedCommitStatus === "failure") {
+    return "failure";
+  }
+  if (normalizedCheckRunsStatus === "pending" || normalizedCommitStatus === "pending") {
+    return "pending";
+  }
+  if (normalizedCheckRunsStatus === "success" || normalizedCommitStatus === "success") {
+    return "success";
+  }
+  return "none";
+}
+
+/**
+ * Normalize the PR `statusCheckRollup` payload into the shared machine-readable contract output.
+ *
+ * @param {Array<object>} rollup
+ * @returns {{
+ *  overallStatus: "success"|"failure"|"pending"|"none",
+ *  rollup: { success: boolean, pending: boolean, failure: boolean, none: boolean },
+ *  semantics: { wait: boolean, blocked: boolean, timeoutDisposition: "remain_waiting"|"not_applicable" }
+ * }}
+ */
+export function normalizeStatusCheckRollupContract(rollup) {
+  return buildCiContract(normalizeStatusCheckRollupStatus(rollup));
+}
+
+/**
+ * Normalize current-head CI inputs into one machine-readable contract output.
+ *
+ * @param {{
+ *  checkRunsStatus?: "success"|"failure"|"pending"|"none"|null,
+ *  commitStatus?: "success"|"failure"|"pending"|"none"|null,
+ *  checkRunsUnsupportedCompleted?: boolean|null
+ * }} input
+ * @returns {{
+ *  overallStatus: "success"|"failure"|"pending"|"none",
+ *  rollup: { success: boolean, pending: boolean, failure: boolean, none: boolean },
+ *  semantics: { wait: boolean, blocked: boolean, timeoutDisposition: "remain_waiting"|"not_applicable" }
+ * }}
+ */
+export function normalizeHeadScopedCiContract({
+  checkRunsStatus = "none",
+  commitStatus = "none",
+  checkRunsUnsupportedCompleted = false,
+} = {}) {
+  const overallStatus = mergeHeadScopedCiStatuses(
+    normalizeHeadScopedCiStatus(checkRunsStatus ?? "none"),
+    normalizeHeadScopedCiStatus(commitStatus ?? "none"),
+  );
+
+  if (checkRunsUnsupportedCompleted === true && overallStatus === "success") {
+    return buildCiContract("none");
+  }
+
+  return buildCiContract(overallStatus);
+}

package/src/loop/copilot-loop-iterations.mjs

@@ -0,0 +1,161 @@
+import { isCopilotLogin, normalizeTimestamp } from "../github/copilot-helpers.mjs";
+
+const ACTIVE_COPILOT_REVIEW_REQUEST_STATUSES = new Set(["requested", "already-requested"]);
+const SUBMITTED_REVIEW_STATES = new Set(["APPROVED", "CHANGES_REQUESTED", "COMMENTED", "DISMISSED"]);
+
+function normalizeReviewRequestEvents(events) {
+  if (!Array.isArray(events)) {
+    return [];
+  }
+
+  return events
+    .map((event) => ({
+      createdAtMs: normalizeTimestamp(event?.createdAt),
+      requestedReviewerLogin: typeof event?.requestedReviewerLogin === "string"
+        ? event.requestedReviewerLogin.trim()
+        : "",
+    }))
+    .filter((event) => event.createdAtMs !== null && isCopilotLogin(event.requestedReviewerLogin))
+    .sort((left, right) => left.createdAtMs - right.createdAtMs);
+}
+
+function normalizeReviews(reviews) {
+  if (!Array.isArray(reviews)) {
+    return [];
+  }
+
+  return reviews
+    .map((review, index) => {
+      const state = typeof review?.state === "string" ? review.state.toUpperCase() : "";
+      const submittedAtMs = normalizeTimestamp(review?.submittedAt ?? review?.createdAt);
+      const authorLogin = typeof review?.authorLogin === "string"
+        ? review.authorLogin.trim()
+        : "";
+      const commitSha = typeof review?.commitSha === "string" && review.commitSha.trim().length > 0
+        ? review.commitSha.trim()
+        : null;
+
+      return {
+        sortKey: index,
+        state,
+        submittedAtMs,
+        authorLogin,
+        commitSha,
+      };
+    })
+    .filter((review) => review.submittedAtMs !== null && isCopilotLogin(review.authorLogin) && SUBMITTED_REVIEW_STATES.has(review.state))
+    .sort((left, right) => left.submittedAtMs - right.submittedAtMs || left.sortKey - right.sortKey);
+}
+
+function normalizeReviewComments(comments) {
+  if (!Array.isArray(comments)) {
+    return [];
+  }
+
+  return comments
+    .map((comment) => ({
+      createdAtMs: normalizeTimestamp(comment?.createdAt),
+      authorLogin: typeof comment?.authorLogin === "string" ? comment.authorLogin.trim() : "",
+    }))
+    .filter((comment) => comment.createdAtMs !== null && isCopilotLogin(comment.authorLogin))
+    .sort((left, right) => left.createdAtMs - right.createdAtMs);
+}
+
+function normalizeCommits(commits) {
+  if (!Array.isArray(commits)) {
+    return [];
+  }
+
+  return commits
+    .map((commit, index) => ({
+      sortKey: index,
+      committedAtMs: normalizeTimestamp(commit?.committedAt),
+      authorLogin: typeof commit?.authorLogin === "string" ? commit.authorLogin.trim() : "",
+      sha: typeof commit?.sha === "string" && commit.sha.trim().length > 0 ? commit.sha.trim() : null,
+    }))
+    .filter((commit) => commit.committedAtMs !== null)
+    .sort((left, right) => left.committedAtMs - right.committedAtMs || left.sortKey - right.sortKey);
+}
+
+function normalizeReviewThreadSummary(summary) {
+  const totalThreads = typeof summary?.totalThreads === "number" && summary.totalThreads >= 0
+    ? Math.floor(summary.totalThreads)
+    : 0;
+  const unresolvedThreads = typeof summary?.unresolvedThreads === "number" && summary.unresolvedThreads >= 0
+    ? Math.floor(summary.unresolvedThreads)
+    : 0;
+
+  return {
+    totalThreads,
+    unresolvedThreads,
+  };
+}
+
+export function summarizeCopilotLoopIterations({
+  reviewRequestEvents,
+  reviews,
+  reviewComments,
+  commits,
+  reviewThreadSummary,
+  currentHeadSha = null,
+  currentReviewRequestStatus = "none",
+  degraded = false,
+  degradedReasons = [],
+} = {}) {
+  const normalizedReviewRequests = normalizeReviewRequestEvents(reviewRequestEvents);
+  const normalizedReviews = normalizeReviews(reviews);
+  const normalizedReviewComments = normalizeReviewComments(reviewComments);
+  const normalizedCommits = normalizeCommits(commits);
+  const normalizedThreadSummary = normalizeReviewThreadSummary(reviewThreadSummary);
+
+  const hasActivePendingRequest = ACTIVE_COPILOT_REVIEW_REQUEST_STATUSES.has(currentReviewRequestStatus);
+  const latestCompletedReview = normalizedReviews.at(-1) ?? null;
+  const latestCompletedReviewAtMs = latestCompletedReview?.submittedAtMs ?? null;
+
+  const pendingCopilotReviewRounds = hasActivePendingRequest
+    && (
+      latestCompletedReviewAtMs === null
+      || normalizedReviewRequests.some((event) => event.createdAtMs > latestCompletedReviewAtMs)
+      || (
+        typeof currentHeadSha === "string"
+        && currentHeadSha.length > 0
+        && latestCompletedReview?.commitSha !== null
+        && latestCompletedReview.commitSha !== currentHeadSha
+      )
+    )
+    ? 1
+    : 0;
+
+  const completedCopilotReviewRounds = normalizedReviews.length;
+  const hasCopilotLoopHistory =
+    completedCopilotReviewRounds > 0
+    || pendingCopilotReviewRounds > 0
+    || normalizedReviewRequests.length > 0
+    || normalizedReviewComments.length > 0;
+
+  if (!hasCopilotLoopHistory) {
+    return {
+      available: false,
+      source: "github_pr_timeline",
+      reason: "no_copilot_review_history",
+    };
+  }
+
+  const firstCopilotFeedbackAtMs = normalizedReviewComments[0]?.createdAtMs ?? null;
+  const fixCommitsAfterFeedback = firstCopilotFeedbackAtMs === null
+    ? 0
+    : normalizedCommits.filter((commit) => commit.committedAtMs > firstCopilotFeedbackAtMs && commit.authorLogin.length > 0 && !isCopilotLogin(commit.authorLogin)).length;
+
+  return {
+    available: true,
+    source: "github_pr_timeline",
+    ...(degraded ? { degraded: true, degradedReasons: Array.isArray(degradedReasons) ? degradedReasons : [] } : {}),
+    completedCopilotReviewRounds,
+    pendingCopilotReviewRounds,
+    copilotReviewRequests: normalizedReviewRequests.length,
+    copilotReviewComments: normalizedReviewComments.length,
+    resolvedReviewThreads: Math.max(0, normalizedThreadSummary.totalThreads - normalizedThreadSummary.unresolvedThreads),
+    unresolvedReviewThreads: normalizedThreadSummary.unresolvedThreads,
+    fixCommitsAfterFeedback,
+  };
+}