@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/lib/platform/completion-backfill.ts

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { COMPLETION_BACKFILL_FAMILIES, inspectCompletionArtifacts } from '../task/finalization-artifacts.ts';
+import { parseArtifactName } from '../task/artifact-lifecycle.ts';
+import { parseTaskFrontmatter } from '../task/frontmatter.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { getOpenWorkflowWarnings } from '../task/workflow-warnings.ts';
+import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
+import { captureTaskWriteMetadata } from '../task/write.ts';
+import { syncPlatformComment } from './issue-comments.ts';
+import type { GitHubClient } from './github-client.ts';
+import { platformResult } from './types.ts';
+import type { PlatformOperation, PlatformResult } from './types.ts';
+
+type CompletionBackfillOptions = { agent: string; cwd?: string; client?: GitHubClient };
+type CompletionBackfillResult = PlatformResult & {
+  artifacts: Array<{ artifact: string; status: PlatformResult['status'] }>;
+  warnings: Array<{ id: string; status: string }>;
+};
+
+function result(
+  base: PlatformResult,
+  artifacts: CompletionBackfillResult['artifacts'],
+  warnings: CompletionBackfillResult['warnings']
+): CompletionBackfillResult {
+  return { ...base, artifacts, warnings };
+}
+
+function excludedPrReview(taskDir: string, message: string): string | null {
+  const names = [...message.matchAll(/(?:^|[^A-Za-z0-9_-])(pr-review(?:-r[1-9]\d*)?\.md)(?=$|[^A-Za-z0-9_.-])/g)]
+    .map((match) => match[1]!);
+  if (names.length !== 1) return null;
+  const parsed = parseArtifactName(names[0]!);
+  if (!parsed || parsed.family !== 'pr-review') return null;
+  const artifactPath = path.join(taskDir, parsed.name);
+  try {
+    const stat = fs.lstatSync(artifactPath);
+    return stat.isFile() && !stat.isSymbolicLink() ? parsed.name : null;
+  } catch {
+    return null;
+  }
+}
+
+function backfillCompletionComments(
+  taskRef: string,
+  options: CompletionBackfillOptions
+): CompletionBackfillResult {
+  const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
+  if (!resolved.ok) return result(platformResult('failed', {
+    error: { code: resolved.code, message: resolved.message, retryable: false }
+  }), [], []);
+  const inventory = inspectCompletionArtifacts(resolved.taskId, { repoRoot: resolved.repoRoot });
+  if (inventory.status === 'failed') return result(platformResult('failed', {
+    error: {
+      code: inventory.error?.code || 'ARTIFACT_TOPOLOGY_CONFLICT',
+      message: inventory.error?.message || 'Completion artifact inventory failed',
+      retryable: false
+    }
+  }), [], []);
+  const initialContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+  const issueNumber = Number(parseTaskFrontmatter(initialContent).issue_number);
+  if (!Number.isInteger(issueNumber) || issueNumber <= 0) return result(platformResult('no-op', {
+    error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
+  }), [], []);
+
+  const artifacts: CompletionBackfillResult['artifacts'] = [];
+  const operations: PlatformOperation[] = [];
+  let latest = platformResult('no-op', { error: null });
+  for (const artifact of inventory.artifacts) {
+    latest = syncPlatformComment(resolved.taskId, {
+      kind: 'artifact',
+      artifact: artifact.name,
+      agent: options.agent,
+      backfill: true,
+      cwd: resolved.repoRoot,
+      client: options.client
+    });
+    operations.push(...latest.operations.map((operation) => ({
+      ...operation,
+      name: `${artifact.name}:${operation.name}`
+    })));
+    artifacts.push({ artifact: artifact.name, status: latest.status });
+    if (latest.status === 'failed' || latest.status === 'blocked') return result({ ...latest, operations }, artifacts, []);
+    if (latest.error) return result(platformResult(latest.error.retryable ? 'blocked' : 'failed', {
+      platform: latest.platform,
+      resource: latest.resource,
+      capabilities: latest.capabilities,
+      operations,
+      error: latest.error
+    }), artifacts, []);
+  }
+
+  const matching = getOpenWorkflowWarnings(initialContent).flatMap((warning) => {
+    if (warning.step !== 'complete-task' || warning.code !== 'COMMENT_SYNC_FAILED' || warning.target !== 'artifact') return [];
+    const excluded = excludedPrReview(resolved.taskDir, warning.message);
+    return excluded ? [{ warning, excluded }] : [];
+  });
+  const warnings: CompletionBackfillResult['warnings'] = [];
+  let metadata: ReturnType<typeof captureTaskWriteMetadata> | null = null;
+  for (const { warning, excluded } of matching) {
+    metadata ??= captureTaskWriteMetadata();
+    const resolution = [
+      `excluded=${excluded}`,
+      `completionFamilies=${COMPLETION_BACKFILL_FAMILIES.join(',')}`,
+      `synchronized=${inventory.artifacts.map((artifact) => artifact.name).join(',') || 'none'}`,
+      `completedAt=${metadata.timestamp}`
+    ].join('; ');
+    const updated = applyWorkflowWarningIntent({
+      kind: 'set-status', taskRef: resolved.taskId, id: warning.id, status: 'resolved', resolution
+    }, { repoRoot: resolved.repoRoot, metadataProvider: () => metadata! });
+    if (updated.status === 'failed') return result(platformResult('failed', {
+      platform: latest.platform,
+      resource: latest.resource,
+      capabilities: latest.capabilities,
+      operations,
+      changed: artifacts.some((item) => item.status === 'applied'),
+      error: { code: updated.error?.code || 'WARNING_UPDATE_FAILED', message: updated.error?.message || 'Unable to resolve workflow warning', retryable: false }
+    }), artifacts, warnings);
+    warnings.push({ id: warning.id, status: updated.status });
+  }
+  const changed = artifacts.some((item) => item.status === 'applied') || warnings.some((item) => item.status === 'applied');
+  return result(platformResult(changed ? 'applied' : 'no-op', {
+    platform: latest.platform,
+    resource: latest.resource,
+    capabilities: latest.capabilities,
+    changed,
+    operations,
+    error: null
+  }), artifacts, warnings);
+}
+
+export { backfillCompletionComments };
+export type { CompletionBackfillOptions, CompletionBackfillResult };

package/lib/platform/issue-comments.ts

@@ -38,7 +38,8 @@ const ARTIFACT_TITLES: Record<string, string> = {
   'review-plan': '技术方案审查',
   code: '实现报告',
   'review-code': '代码审查',
-  'manual-validation': '人工验证报告'
+  'manual-validation': '人工验证报告',
+  'pr-review': 'PR 审查报告'
 };
 
 function normalizeCommentContent(content: string): string {
@@ -74,7 +75,7 @@ function renderTaskComment(content: string, taskId: string, agent: string): stri
 
 function artifactIdentity(artifact: string): { stem: string; title: string } {
   const stem = path.basename(artifact, '.md');
-  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation)(?:-r(\d+))?$/);
+  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|pr-review)(?:-r(\d+))?$/);
   if (!match) throw new Error(`unsupported artifact '${artifact}'`);
   const base = ARTIFACT_TITLES[match[1]!]!;
   const round = match[2] ? Number(match[2]) : 1;

package/lib/platform/merged-pr-equivalence.ts

@@ -1,4 +1,7 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
 import type { PullRequestSnapshot } from "./pull-requests.ts";
 
@@ -6,11 +9,21 @@ const SHA_PATTERN = /^[0-9a-f]{40}$/i;
 
 type ReviewedHeadRelation =
   | { status: "strict"; reviewedHead: string }
-  | { status: "merged-equivalent"; reviewedHead: string; mergeCommit: string }
+  | {
+      status: "merged-equivalent";
+      reviewedHead: string;
+      mergeCommit: string;
+      comparisonHead: string;
+    }
   | { status: "failed" | "blocked"; code: string; message: string };
 
 function git(cwd: string, args: string[]): string {
-  return execFileSync("git", args, { cwd, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 32 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
 }
 
 function commitExists(gitRoot: string, sha: string): boolean {
@@ -22,48 +35,194 @@ function commitExists(gitRoot: string, sha: string): boolean {
   }
 }
 
+function isAncestor(gitRoot: string, ancestor: string, descendant: string):
+  | { status: "yes" | "no" }
+  | { status: "error" } {
+  const result = spawnSync("git", ["merge-base", "--is-ancestor", ancestor, descendant], {
+    cwd: gitRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.status === 0) return { status: "yes" };
+  if (result.status === 1) return { status: "no" };
+  return { status: "error" };
+}
+
+function blocked(message: string): ReviewedHeadRelation {
+  return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message };
+}
+
+function resolveUniqueMergeBase(
+  gitRoot: string,
+  reviewedHead: string,
+  squashParent: string
+): { status: "ok"; mergeBase: string } | { status: "failed" | "blocked"; relation: ReviewedHeadRelation } {
+  const result = spawnSync("git", ["merge-base", "--all", reviewedHead, squashParent], {
+    cwd: gitRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error || result.status === null || result.status > 1) {
+    return { status: "blocked", relation: blocked("Unable to compute the reviewed PR merge base") };
+  }
+  const candidates = result.stdout.trim() === "" ? [] : result.stdout.trim().split(/\s+/);
+  if (result.status === 1 || candidates.length !== 1) {
+    return {
+      status: "failed",
+      relation: {
+        status: "failed",
+        code: "PR_MERGE_TOPOLOGY_INVALID",
+        message: "Reviewed head and squash parent do not have a unique merge base"
+      }
+    };
+  }
+  const [candidate] = candidates;
+  if (!candidate || !SHA_PATTERN.test(candidate)) {
+    return { status: "blocked", relation: blocked("Git returned an invalid reviewed PR merge base") };
+  }
+  return { status: "ok", mergeBase: candidate };
+}
+
+function compareReplayedTree(input: {
+  gitRoot: string;
+  mergeBase: string;
+  reviewedHead: string;
+  squashParent: string;
+  squashCommit: string;
+}): ReviewedHeadRelation | null {
+  const { gitRoot, mergeBase, reviewedHead, squashParent, squashCommit } = input;
+  let tempDir: string | undefined;
+  let relation: ReviewedHeadRelation | null = null;
+  try {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-infra-merge-equivalence-"));
+    const env = { ...process.env, GIT_INDEX_FILE: path.join(tempDir, "index") };
+    const readTree = spawnSync("git", ["read-tree", squashParent], {
+      cwd: gitRoot, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (readTree.error || readTree.status !== 0) {
+      relation = blocked("Unable to initialize isolated squash merge evidence");
+    } else {
+      const patchResult = spawnSync(
+        "git",
+        ["diff", "--no-renames", "--binary", "--full-index", mergeBase, reviewedHead],
+        { cwd: gitRoot, env, encoding: "utf8", maxBuffer: 32 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] }
+      );
+      if (patchResult.error || patchResult.status !== 0) {
+        relation = blocked("Unable to generate the reviewed PR patch");
+      } else if (patchResult.stdout !== "") {
+        const applyResult = spawnSync("git", ["apply", "--cached", "--3way", "--binary", "-q"], {
+          cwd: gitRoot,
+          env,
+          encoding: "utf8",
+          input: patchResult.stdout,
+          maxBuffer: 32 * 1024 * 1024,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        if (applyResult.status === 1) {
+          relation = {
+            status: "failed",
+            code: "PR_MERGE_CONTENT_MISMATCH",
+            message: "Reviewed PR patch cannot be replayed without conflicts, so content equivalence cannot be established"
+          };
+        } else if (applyResult.error || applyResult.status !== 0) {
+          relation = blocked("Unable to replay the reviewed PR patch");
+        }
+      }
+      if (relation === null) {
+        const compareResult = spawnSync(
+          "git",
+          ["diff", "--cached", "--quiet", "--no-ext-diff", squashCommit, "--"],
+          { cwd: gitRoot, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
+        );
+        if (compareResult.status === 1) {
+          relation = {
+            status: "failed",
+            code: "PR_MERGE_CONTENT_MISMATCH",
+            message: "Replayed reviewed PR content differs from the squash merge tree"
+          };
+        } else if (compareResult.error || compareResult.status !== 0) {
+          relation = blocked("Unable to compare replayed PR content with the squash merge tree");
+        }
+      }
+    }
+  } catch {
+    relation = blocked("Unable to create isolated squash merge evidence");
+  } finally {
+    if (tempDir) {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch {
+        relation = blocked("Unable to clean up isolated squash merge evidence");
+      }
+    }
+  }
+  return relation;
+}
+
 export function resolveReviewedHeadRelation(input: {
   gitRoot: string;
-  localHead: string;
+  comparisonHead: string;
   lastReviewedCommit: string;
   pullRequest: PullRequestSnapshot;
-  pathspecs: string[];
 }): ReviewedHeadRelation {
-  const { gitRoot, localHead, lastReviewedCommit, pullRequest, pathspecs } = input;
-  if (localHead === lastReviewedCommit && lastReviewedCommit === pullRequest.head.sha) {
+  const { gitRoot, comparisonHead, lastReviewedCommit, pullRequest } = input;
+  if (
+    comparisonHead === lastReviewedCommit &&
+    lastReviewedCommit === pullRequest.head.sha &&
+    !(pullRequest.state === "closed" && pullRequest.mergedAt && pullRequest.mergeCommitSha)
+  ) {
     return { status: "strict", reviewedHead: lastReviewedCommit };
   }
   if (pullRequest.state !== "closed" || !pullRequest.mergedAt || !pullRequest.mergeCommitSha ||
       lastReviewedCommit !== pullRequest.head.sha) {
     return { status: "failed", code: "PR_MERGE_IDENTITY_INVALID", message: "PR merge identity does not match the reviewed head" };
   }
-  const shas = [pullRequest.base.sha, pullRequest.head.sha, pullRequest.mergeCommitSha, localHead];
+  const shas = [pullRequest.base.sha, pullRequest.head.sha, pullRequest.mergeCommitSha, comparisonHead];
   if (shas.some((sha) => !SHA_PATTERN.test(sha) || !commitExists(gitRoot, sha))) {
     return { status: "blocked", code: "PR_MERGE_OBJECT_MISSING", message: "Required PR merge Git objects are unavailable" };
   }
+  const ancestry = isAncestor(gitRoot, pullRequest.mergeCommitSha, comparisonHead);
+  if (ancestry.status === "no") {
+    return {
+      status: "failed",
+      code: "PR_MERGE_TARGET_MISMATCH",
+      message: "PR merge commit is not in the authoritative target history"
+    };
+  }
+  if (ancestry.status === "error") {
+    return {
+      status: "blocked",
+      code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE",
+      message: "Unable to verify PR merge ancestry"
+    };
+  }
   try {
-    git(gitRoot, ["merge-base", "--is-ancestor", pullRequest.mergeCommitSha, localHead]);
     const parents = git(gitRoot, ["rev-list", "--parents", "-n", "1", pullRequest.mergeCommitSha]).trim().split(/\s+/);
     if (parents.length !== 2) {
       return { status: "failed", code: "PR_MERGE_TOPOLOGY_INVALID", message: "PR merge commit is not a single-parent squash commit" };
     }
-    const diffArgs = ["diff", "--no-renames", "--binary", "--full-index"];
-    const reviewedDiff = git(gitRoot, [...diffArgs, pullRequest.base.sha, pullRequest.head.sha]);
-    const mergedDiff = git(gitRoot, [...diffArgs, `${pullRequest.mergeCommitSha}^`, pullRequest.mergeCommitSha]);
-    if (reviewedDiff !== mergedDiff) {
-      return { status: "failed", code: "PR_MERGE_CONTENT_MISMATCH", message: "Squash merge content differs from the reviewed PR changes" };
-    }
-    const postMerge = git(gitRoot, ["rev-list", `${pullRequest.mergeCommitSha}..${localHead}`, "--", ...pathspecs]).trim();
-    if (postMerge) {
-      return { status: "failed", code: "POST_MERGE_CHANGES", message: "Protected paths changed after the squash merge" };
+    const squashParent = parents[1];
+    if (!squashParent) {
+      return { status: "failed", code: "PR_MERGE_TOPOLOGY_INVALID", message: "PR merge commit is not a single-parent squash commit" };
     }
+    const mergeBase = resolveUniqueMergeBase(gitRoot, pullRequest.head.sha, squashParent);
+    if (mergeBase.status !== "ok") return mergeBase.relation;
+    const replayFailure = compareReplayedTree({
+      gitRoot,
+      mergeBase: mergeBase.mergeBase,
+      reviewedHead: pullRequest.head.sha,
+      squashParent,
+      squashCommit: pullRequest.mergeCommitSha
+    });
+    if (replayFailure) return replayFailure;
   } catch {
     return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message: "Unable to verify PR merge topology or content" };
   }
   return {
     status: "merged-equivalent",
     reviewedHead: lastReviewedCommit,
-    mergeCommit: pullRequest.mergeCommitSha
+    mergeCommit: pullRequest.mergeCommitSha,
+    comparisonHead
   };
 }