@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/dist/lib/platform/change-request-git-evidence.js

@@ -0,0 +1,113 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+import { resolvePlatformChangeRequestGitEvidence } from "./adapters.js";
+import { resolveReviewedHeadRelation } from "./merged-pr-equivalence.js";
+const SHA_PATTERN = /^[0-9a-f]{40}$/i;
+const REVIEWED_HEAD_REF = "refs/agent-infra/reviewed-head";
+const TARGET_HEAD_REF = "refs/agent-infra/target-head";
+function git(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: 32 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"]
+    }).trim();
+}
+function validRef(ref) {
+    return spawnSync("git", ["check-ref-format", ref], {
+        encoding: "utf8",
+        stdio: ["ignore", "ignore", "ignore"]
+    }).status === 0;
+}
+function blocked(code, message) {
+    return { status: "blocked", code, message };
+}
+function failed(code, message) {
+    return { status: "failed", code, message };
+}
+function validMergeIdentity(lastReviewedCommit, pullRequest) {
+    if (pullRequest.state !== "closed" ||
+        !pullRequest.mergedAt ||
+        !pullRequest.mergeCommitSha ||
+        !SHA_PATTERN.test(lastReviewedCommit) ||
+        lastReviewedCommit !== pullRequest.head.sha) {
+        return failed("PR_MERGE_IDENTITY_INVALID", "PR merge identity does not match the reviewed head");
+    }
+    return null;
+}
+function resolveMaterializedReviewedHeadRelation(input) {
+    const identityFailure = validMergeIdentity(input.lastReviewedCommit, input.pullRequest);
+    if (identityFailure)
+        return identityFailure;
+    const source = resolvePlatformChangeRequestGitEvidence(input.platformType, {
+        cwd: input.cwd,
+        repository: input.pullRequest.repository,
+        number: input.pullRequest.number,
+        pullRequest: input.pullRequest
+    });
+    if (!source.ok || !source.value) {
+        return blocked(source.error?.code || "PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE", source.error?.message || "Unable to resolve authoritative PR Git evidence");
+    }
+    if (!source.value.remoteUrl.trim() ||
+        source.value.remoteUrl.trimStart().startsWith("-") ||
+        !validRef(source.value.reviewedHeadRef) ||
+        !validRef(source.value.targetHeadRef)) {
+        return blocked("PR_MERGE_EVIDENCE_SOURCE_UNAVAILABLE", "Platform returned an invalid PR Git evidence source");
+    }
+    let evidenceRoot = null;
+    let phase = "prepare";
+    let result = blocked("PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", "Unable to prepare isolated PR Git evidence");
+    try {
+        evidenceRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agent-infra-pr-evidence-"));
+        execFileSync("git", ["init", "--bare", "-q", evidenceRoot], {
+            cwd: input.cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        phase = "fetch";
+        git(evidenceRoot, [
+            "fetch",
+            "--no-tags",
+            "--no-write-fetch-head",
+            source.value.remoteUrl,
+            `+${source.value.reviewedHeadRef}:${REVIEWED_HEAD_REF}`,
+            `+${source.value.targetHeadRef}:${TARGET_HEAD_REF}`
+        ]);
+        phase = "resolve";
+        const fetchedReviewedHead = git(evidenceRoot, ["rev-parse", `${REVIEWED_HEAD_REF}^{commit}`]);
+        const comparisonHead = git(evidenceRoot, ["rev-parse", `${TARGET_HEAD_REF}^{commit}`]);
+        if (fetchedReviewedHead !== input.pullRequest.head.sha) {
+            result = failed("PR_MERGE_FETCHED_HEAD_MISMATCH", "Fetched PR head does not match the authoritative platform snapshot");
+        }
+        else {
+            result = resolveReviewedHeadRelation({
+                gitRoot: evidenceRoot,
+                comparisonHead,
+                lastReviewedCommit: input.lastReviewedCommit,
+                pullRequest: input.pullRequest
+            });
+        }
+    }
+    catch {
+        result = phase === "fetch"
+            ? blocked("PR_MERGE_EVIDENCE_FETCH_FAILED", "Unable to fetch PR Git evidence; verify Git credentials and platform refs")
+            : phase === "resolve"
+                ? blocked("PR_MERGE_OBJECT_MISSING", "Fetched PR Git evidence is incomplete")
+                : blocked("PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", "Unable to prepare isolated PR Git evidence");
+    }
+    finally {
+        if (evidenceRoot) {
+            try {
+                fs.rmSync(evidenceRoot, { recursive: true, force: true });
+            }
+            catch {
+                result = blocked("PR_MERGE_EVIDENCE_CLEANUP_FAILED", "Unable to clean up isolated PR Git evidence");
+            }
+        }
+    }
+    return result;
+}
+export { resolveMaterializedReviewedHeadRelation };
+//# sourceMappingURL=change-request-git-evidence.js.map

package/dist/lib/platform/completion-backfill.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { COMPLETION_BACKFILL_FAMILIES, inspectCompletionArtifacts } from '../task/finalization-artifacts.js';
+import { parseArtifactName } from '../task/artifact-lifecycle.js';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { getOpenWorkflowWarnings } from '../task/workflow-warnings.js';
+import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.js';
+import { captureTaskWriteMetadata } from '../task/write.js';
+import { syncPlatformComment } from './issue-comments.js';
+import { platformResult } from './types.js';
+function result(base, artifacts, warnings) {
+    return { ...base, artifacts, warnings };
+}
+function excludedPrReview(taskDir, message) {
+    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, options) {
+    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 = [];
+    const operations = [];
+    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 = [];
+    let metadata = 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 };
+//# sourceMappingURL=completion-backfill.js.map

package/dist/lib/platform/issue-comments.js

@@ -19,7 +19,8 @@ const ARTIFACT_TITLES = {
     'review-plan': '技术方案审查',
     code: '实现报告',
     'review-code': '代码审查',
-    'manual-validation': '人工验证报告'
+    'manual-validation': '人工验证报告',
+    'pr-review': 'PR 审查报告'
 };
 function normalizeCommentContent(content) {
     return content.replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
@@ -51,7 +52,7 @@ function renderTaskComment(content, taskId, agent) {
 }
 function artifactIdentity(artifact) {
     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]];

package/dist/lib/platform/merged-pr-equivalence.js

@@ -1,7 +1,15 @@
-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";
 const SHA_PATTERN = /^[0-9a-f]{40}$/i;
 function git(cwd, args) {
-    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, sha) {
     try {
@@ -12,35 +20,166 @@ function commitExists(gitRoot, sha) {
         return false;
     }
 }
+function isAncestor(gitRoot, ancestor, descendant) {
+    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) {
+    return { status: "blocked", code: "PR_MERGE_GIT_EVIDENCE_UNAVAILABLE", message };
+}
+function resolveUniqueMergeBase(gitRoot, reviewedHead, squashParent) {
+    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) {
+    const { gitRoot, mergeBase, reviewedHead, squashParent, squashCommit } = input;
+    let tempDir;
+    let relation = 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) {
-    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" };
@@ -48,7 +187,8 @@ export function resolveReviewedHeadRelation(input) {
     return {
         status: "merged-equivalent",
         reviewedHead: lastReviewedCommit,
-        mergeCommit: pullRequest.mergeCommitSha
+        mergeCommit: pullRequest.mergeCommitSha,
+        comparisonHead
     };
 }
 //# sourceMappingURL=merged-pr-equivalence.js.map