@fitlab-ai/agent-infra 0.8.5 → 0.9.1

package/lib/platform/types.ts

@@ -0,0 +1,74 @@
+type PlatformStatus = 'planned' | 'applied' | 'no-op' | 'degraded' | 'failed' | 'blocked';
+
+type PlatformError = {
+  code: string;
+  message: string;
+  retryable: boolean;
+};
+
+type PlatformCapabilities = {
+  authenticated: boolean;
+  comment: boolean;
+  triage: boolean;
+  push: boolean;
+  admin: boolean;
+};
+
+type PlatformOperation = {
+  name: string;
+  status: 'planned' | 'applied' | 'no-op' | 'skipped' | 'failed';
+  reasonCode: string | null;
+};
+
+type CommentIdentity = {
+  kind: 'task' | 'artifact' | 'summary' | 'cancel';
+  marker: string;
+  ids: number[];
+  parts: number;
+};
+
+type PlatformResult = {
+  status: PlatformStatus;
+  changed: boolean;
+  platform: { type: string | null; repository: string | null; currentUser: string | null };
+  resource: { kind: 'repository' | 'issue' | 'pull-request'; number: number | null };
+  capabilities: PlatformCapabilities;
+  operations: PlatformOperation[];
+  comment: CommentIdentity | null;
+  error: PlatformError | null;
+};
+
+const EMPTY_CAPABILITIES: PlatformCapabilities = {
+  authenticated: false,
+  comment: false,
+  triage: false,
+  push: false,
+  admin: false
+};
+
+function platformResult(
+  status: PlatformStatus,
+  overrides: Partial<PlatformResult> = {}
+): PlatformResult {
+  return {
+    status,
+    changed: status === 'applied',
+    platform: { type: null, repository: null, currentUser: null },
+    resource: { kind: 'repository', number: null },
+    capabilities: { ...EMPTY_CAPABILITIES },
+    operations: [],
+    comment: null,
+    error: null,
+    ...overrides
+  };
+}
+
+export { EMPTY_CAPABILITIES, platformResult };
+export type {
+  CommentIdentity,
+  PlatformCapabilities,
+  PlatformError,
+  PlatformOperation,
+  PlatformResult,
+  PlatformStatus
+};

package/lib/platform/verification-required.ts

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { inspectRequiredChecks } from "./pr-checks.ts";
+import { resolvePlatformContext } from "./context.ts";
+import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.ts";
+import { loadPostReviewConfig, resolvePostReviewGlobs } from "../task/review-fingerprint.ts";
+
+const CHECK_TYPE = "required-checks";
+const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
+
+function validPrNumber(value: any): any {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0;
+}
+
+function readPrFlow(repoRoot: any): any {
+  try {
+    const config = JSON.parse(fs.readFileSync(path.join(repoRoot, ".agents", ".airc.json"), "utf8"));
+    return config.prFlow;
+  } catch {
+    return undefined;
+  }
+}
+
+function readHead(repoRoot: any): any {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+export function evaluateRequiredChecks(context: any, shared: any): any {
+  const { metadata, localHead, inspection, prFlow } = context;
+  if (prFlow === "disabled" || metadata.pr_status === "skipped" || !validPrNumber(metadata.pr_number)) {
+    return shared.passResult(CHECK_TYPE, "Skipped: required checks are not applicable to this task");
+  }
+
+  const reviewedHead = String(metadata.last_reviewed_commit || "");
+  if (!localHead || !SHA_PATTERN.test(localHead)) {
+    return shared.blockedResult(CHECK_TYPE, "Unable to resolve the local HEAD", "dependency_error");
+  }
+  if (!SHA_PATTERN.test(reviewedHead)) {
+    return shared.failResult(CHECK_TYPE, "Task has no valid last_reviewed_commit", "check_failed");
+  }
+  if (!inspection || inspection.status === "blocked") {
+    return shared.blockedResult(CHECK_TYPE, inspection?.error?.message || "Required checks are unavailable", "network_error");
+  }
+  if (inspection.status === "failed") {
+    return shared.failResult(CHECK_TYPE, inspection.error?.message || "Required checks are unavailable", "check_failed");
+  }
+
+  const prHead = inspection.pullRequest?.head?.sha || inspection.pullRequest?.headSha;
+  const relation = context.relation || (
+    context.gitRoot && inspection.pullRequest?.head
+      ? resolveReviewedHeadRelation({
+          gitRoot: context.gitRoot,
+          localHead,
+          lastReviewedCommit: reviewedHead,
+          pullRequest: inspection.pullRequest,
+          pathspecs: context.pathspecs || [":/"]
+        })
+      : localHead === reviewedHead && localHead === prHead
+        ? { status: "strict" }
+        : { status: "failed" }
+  );
+  if (relation.status !== "strict" && relation.status !== "merged-equivalent") {
+    const message = relation.message || "Local HEAD, last reviewed commit, and PR head must match";
+    return relation.status === "blocked"
+      ? shared.blockedResult(CHECK_TYPE, message, "dependency_error")
+      : shared.failResult(CHECK_TYPE, message, "check_failed");
+  }
+
+  const state = inspection.checks?.state;
+  if (state === "passed" || state === "no-required") {
+    const suffix = relation.status === "merged-equivalent" ? " via verified squash merge equivalence" : "";
+    return shared.passResult(CHECK_TYPE, `Required checks are ${state} for PR head ${prHead}${suffix}`);
+  }
+  if (state === "pending") {
+    return shared.blockedResult(CHECK_TYPE, inspection.error?.message || "Required checks are pending", "check_pending");
+  }
+  return shared.failResult(CHECK_TYPE, inspection.error?.message || `Required checks are ${state || "unavailable"}`, "check_failed");
+}
+
+export function check({ taskDir }: any, shared: any): any {
+  const task = shared.loadTask(taskDir);
+  if (!task.ok) return shared.failResult(CHECK_TYPE, task.message);
+  const platform = resolvePlatformContext({ cwd: shared.repoRoot });
+  if (platform.platform.type !== "github") {
+    return shared.passResult(CHECK_TYPE, "Skipped: this code platform does not provide required checks");
+  }
+  const prFlow = readPrFlow(shared.repoRoot);
+  if (prFlow === "disabled" || task.metadata.pr_status === "skipped" || !validPrNumber(task.metadata.pr_number)) {
+    return evaluateRequiredChecks({ metadata: task.metadata, localHead: null, inspection: null, prFlow }, shared);
+  }
+  const localHead = readHead(shared.repoRoot);
+  if (!localHead) return evaluateRequiredChecks({ metadata: task.metadata, localHead, inspection: null, prFlow }, shared);
+  const inspection = inspectRequiredChecks(task.metadata.id, { cwd: shared.repoRoot });
+  return evaluateRequiredChecks({
+    metadata: task.metadata,
+    localHead,
+    inspection,
+    prFlow,
+    gitRoot: shared.repoRoot,
+    pathspecs: resolvePostReviewGlobs({}, loadPostReviewConfig(shared.repoRoot))
+  }, shared);
+}