@fitlab-ai/agent-infra 0.9.1 → 0.9.3

package/dist/lib/platform/pr-checks.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
+import { inspectPlatformRequiredChecks, registerPlatformCapabilities } from './adapters.js';
 import { resolvePlatformContext } from './context.js';
 import { createGitHubClient } from './github-client.js';
 import { inspectPlatformPullRequest } from './pull-requests.js';
@@ -16,21 +17,14 @@ function classifyRequiredChecks(required) {
         return { state: 'pending', required };
     return { state: 'passed', required };
 }
-async function watchRequiredChecks(options) {
-    const now = options.now || (() => performance.now());
-    const sleep = options.sleep || ((delay) => new Promise((resolve) => setTimeout(resolve, delay)));
-    const started = now();
-    while (true) {
-        if (options.signal?.aborted)
-            return { state: 'cancelled', required: [] };
-        const snapshot = await options.inspect();
-        if (snapshot.state !== 'pending')
-            return snapshot;
-        const elapsed = now() - started;
-        if (elapsed >= options.deadlineMs)
-            return { state: 'timed-out', required: snapshot.required };
-        await sleep(Math.min(options.intervalMs, options.deadlineMs - elapsed));
-    }
+function classifyPullRequestReadiness(input) {
+    if (input.mergeability === 'conflicting')
+        return { state: 'conflicting', headSha: input.headSha };
+    if (input.checks.state === 'failed' || input.checks.state === 'cancelled')
+        return { state: 'checks-failed', headSha: input.headSha };
+    if (input.mergeability === 'unknown' || input.checks.state === 'pending')
+        return { state: 'pending', headSha: input.headSha };
+    return { state: 'ready', headSha: input.headSha };
 }
 function parseRunJobIdentity(detailsUrl) {
     try {
@@ -87,6 +81,18 @@ function normalizeChecks(value) {
             }] : [];
     });
 }
+registerPlatformCapabilities('github', {
+    inspectRequiredChecks({ client, repository, number, cwd }) {
+        const github = client || createGitHubClient();
+        const inspected = github.json([
+            'pr', 'checks', String(number), '--repo', repository, '--required',
+            '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
+        ], { cwd });
+        return inspected.ok
+            ? { ok: true, value: normalizeChecks(inspected.value) }
+            : { ok: false, error: inspected.error };
+    }
+});
 function resolvedTask(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
@@ -109,19 +115,30 @@ function inspectRequiredChecks(taskRef, options = {}) {
     const base = resolvedTask(taskRef, options);
     if (!base.ok)
         return base.output;
+    return inspectChecksForResolvedTask(base, options);
+}
+function inspectChecksForResolvedTask(base, options) {
     const repository = base.context.platform.repository;
-    const inspected = base.client.json([
-        'pr', 'checks', String(base.prNumber), '--repo', repository, '--required',
-        '--json', 'name,state,bucket,link,workflow,startedAt,completedAt'
-    ], { cwd: base.resolved.repoRoot });
-    if (!inspected.ok) {
-        return checksResult(inspected.error.retryable ? 'blocked' : 'failed', {
+    const inspected = inspectPlatformRequiredChecks(base.context.platform.type, {
+        cwd: base.resolved.repoRoot,
+        repository,
+        number: base.prNumber,
+        headSha: base.pullRequest.head.sha,
+        client: options.client || base.client
+    });
+    if (!inspected.ok || !inspected.value) {
+        const error = inspected.error || {
+            code: 'REQUIRED_CHECKS_INSPECTION_INVALID',
+            message: 'Platform adapter returned no required-checks snapshot',
+            retryable: false
+        };
+        return checksResult(error.retryable ? 'blocked' : 'failed', {
             platform: base.context.platform, capabilities: base.context.capabilities,
             resource: { kind: 'pull-request', number: base.prNumber },
-            pullRequest: base.pullRequest, error: inspected.error
+            pullRequest: base.pullRequest, error
         });
     }
-    const classified = classifyRequiredChecks(normalizeChecks(inspected.value));
+    const classified = classifyRequiredChecks(inspected.value);
     const status = classified.state === 'passed' || classified.state === 'no-required'
         ? 'no-op'
         : classified.state === 'failed' || classified.state === 'cancelled' ? 'failed' : 'blocked';
@@ -136,33 +153,60 @@ function inspectRequiredChecks(taskRef, options = {}) {
         }
     });
 }
-async function watchPlatformChecks(taskRef, options) {
-    let last = null;
-    const watched = await watchRequiredChecks({
-        intervalMs: options.intervalSeconds * 1000,
-        deadlineMs: options.deadlineSeconds * 1000,
-        signal: options.signal,
-        now: options.now,
-        sleep: options.sleep,
-        inspect: async () => {
-            last = inspectRequiredChecks(taskRef, options);
-            if (last.checks.state === 'pending' && last.error?.code === 'REQUIRED_CHECKS_PENDING')
-                return last.checks;
-            return last.checks;
+function inspectPullRequestReadiness(taskRef, options = {}) {
+    const base = resolvedTask(taskRef, options);
+    if (!base.ok)
+        return base.output;
+    const checked = inspectChecksForResolvedTask(base, options);
+    const classifiedCodes = new Set(['REQUIRED_CHECKS_PENDING', 'REQUIRED_CHECKS_FAILED', 'REQUIRED_CHECKS_CANCELLED']);
+    if (checked.error && !classifiedCodes.has(checked.error.code))
+        return checked;
+    const readiness = classifyPullRequestReadiness({
+        headSha: base.pullRequest.head.sha,
+        mergeability: base.pullRequest.mergeability?.state ?? 'unknown',
+        checks: checked.checks
+    });
+    const status = readiness.state === 'ready' ? 'no-op'
+        : readiness.state === 'conflicting' || readiness.state === 'checks-failed' ? 'failed' : 'blocked';
+    return checksResult(status, {
+        ...checked,
+        status,
+        changed: false,
+        readiness,
+        error: status === 'no-op' ? null : {
+            code: readiness.state === 'conflicting' ? 'PR_MERGE_CONFLICT'
+                : readiness.state === 'checks-failed' ? 'REQUIRED_CHECKS_FAILED' : 'PR_READINESS_PENDING',
+            message: `Pull request readiness is ${readiness.state}`,
+            retryable: readiness.state === 'pending'
         }
     });
-    if (!last)
-        return checksResult('blocked', { checks: watched, error: { code: 'REQUIRED_CHECKS_UNAVAILABLE', message: 'No checks snapshot was produced', retryable: true } });
-    const snapshot = last;
-    if (watched.state === 'timed-out' || watched.state === 'cancelled')
-        return checksResult('blocked', {
-            ...snapshot,
-            status: 'blocked',
-            changed: false,
-            checks: watched,
-            error: { code: watched.state === 'timed-out' ? 'REQUIRED_CHECKS_TIMEOUT' : 'REQUIRED_CHECKS_CANCELLED', message: `Required checks ${watched.state}`, retryable: watched.state === 'timed-out' }
-        });
-    return { ...snapshot, checks: watched };
+}
+async function watchPullRequestReadiness(taskRef, options) {
+    const now = options.now || (() => performance.now());
+    const sleep = options.sleep || ((delay) => new Promise((resolve) => setTimeout(resolve, delay)));
+    const started = now();
+    let last = null;
+    while (true) {
+        if (options.signal?.aborted)
+            return checksResult('blocked', {
+                ...last,
+                status: 'blocked', changed: false,
+                readiness: { state: 'cancelled', headSha: last?.pullRequest?.head.sha ?? '' },
+                error: { code: 'PR_READINESS_CANCELLED', message: 'Pull request readiness watch was cancelled', retryable: false }
+            });
+        last = inspectPullRequestReadiness(taskRef, options);
+        if (last.readiness?.state !== 'pending' || last.error?.code !== 'PR_READINESS_PENDING')
+            return last;
+        const elapsed = now() - started;
+        if (elapsed >= options.deadlineSeconds * 1000)
+            return checksResult('blocked', {
+                ...last,
+                status: 'blocked', changed: false,
+                readiness: { state: 'timed-out', headSha: last.pullRequest?.head.sha ?? '' },
+                error: { code: 'PR_READINESS_TIMEOUT', message: 'Pull request readiness watch timed out', retryable: true }
+            });
+        await sleep(Math.min(options.intervalSeconds * 1000, options.deadlineSeconds * 1000 - elapsed));
+    }
 }
 function resolvePlatformCheckRun(taskRef, options) {
     const base = resolvedTask(taskRef, options);
@@ -194,6 +238,13 @@ function resolvePlatformCheckRun(taskRef, options) {
         error: resolution.status === 'resolved' ? null : { code: resolution.status === 'ambiguous' ? 'CHECK_RUN_AMBIGUOUS' : 'CHECK_RUN_NOT_FOUND', message: `Check run is ${resolution.status}`, retryable: false }
     });
 }
+function fetchCheckLogText(client, args, cwd) {
+    const fetched = client.text(args, { cwd });
+    if (fetched.ok || args[0] !== 'api' || !/response contains terminal escape sequences/i.test(fetched.error.message)) {
+        return fetched;
+    }
+    return client.text([...args, '--allow-escape-sequences'], { cwd });
+}
 function fetchPlatformCheckLogs(taskRef, options) {
     const base = resolvedTask(taskRef, options);
     if (!base.ok)
@@ -201,7 +252,7 @@ function fetchPlatformCheckLogs(taskRef, options) {
     const args = options.job
         ? ['api', `repos/${base.context.platform.repository}/actions/jobs/${options.job}/logs`]
         : ['run', 'view', String(options.run), '--repo', base.context.platform.repository, '--log-failed'];
-    const fetched = base.client.text(args, { cwd: base.resolved.repoRoot });
+    const fetched = fetchCheckLogText(base.client, args, base.resolved.repoRoot);
     if (!fetched.ok)
         return checksResult(fetched.error.retryable ? 'blocked' : 'failed', { platform: base.context.platform, capabilities: base.context.capabilities, error: fetched.error });
     if (!fetched.value)
@@ -212,5 +263,5 @@ function fetchPlatformCheckLogs(taskRef, options) {
         logs: { runId: options.run, ...(options.job ? { jobId: options.job } : {}), text: fetched.value }, error: null
     });
 }
-export { classifyRequiredChecks, fetchPlatformCheckLogs, inspectRequiredChecks, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPlatformChecks, watchRequiredChecks };
+export { classifyPullRequestReadiness, classifyRequiredChecks, fetchCheckLogText, fetchPlatformCheckLogs, inspectRequiredChecks, inspectPullRequestReadiness, parseRunJobIdentity, resolvePlatformCheckRun, resolveRunCandidate, watchPullRequestReadiness };
 //# sourceMappingURL=pr-checks.js.map

package/dist/lib/platform/pr-review.js

@@ -0,0 +1,166 @@
+import { createGitHubClient } from './github-client.js';
+import { resolvePlatformContext } from './context.js';
+import { platformResult } from './types.js';
+const REVIEW_EVENTS = ['COMMENT', 'APPROVE', 'REQUEST_CHANGES'];
+// Marker-safe scope: a task id (`TASK-YYYYMMDD-HHMMSS`) or a bare PR number
+// (`pr{N}`). Any other value (e.g. one containing `\r\n` or `-->`) would break
+// the first-line marker idempotency contract of `reviewMarker` (PL-6).
+const REVIEW_SCOPE_PATTERN = /^(?:pr\d+|TASK-\d{8}-\d{6})$/;
+export function reviewMarker(identity) {
+    return `<!-- review-pr:${identity.scope}:r${identity.round} -->`;
+}
+export function reviewedCommitMarker(sha) {
+    return `<!-- reviewed-commit: ${sha} -->`;
+}
+function normalizeBody(body) {
+    return String(body || '').replace(/\r\n/g, '\n').replace(/\n+$/, '\n');
+}
+function firstLine(body) {
+    return normalizeBody(String(body || '')).split('\n', 1)[0] || '';
+}
+function hasUsableContext(context) {
+    return (context.status === 'no-op' || context.status === 'degraded') && context.platform.repository !== null;
+}
+function invalidPrNumber(prNumber) {
+    return !Number.isInteger(prNumber) || prNumber <= 0;
+}
+export function listPrReviews(prNumber, options = {}) {
+    const client = options.client || createGitHubClient();
+    const context = resolvePlatformContext({ cwd: options.cwd || process.cwd(), client });
+    if (!hasUsableContext(context)) {
+        return { ...platformResult(context.status, { platform: context.platform, capabilities: context.capabilities, error: context.error }), reviews: [] };
+    }
+    const repository = context.platform.repository;
+    if (invalidPrNumber(prNumber)) {
+        return {
+            ...platformResult('failed', {
+                platform: context.platform, capabilities: context.capabilities,
+                error: { code: 'PR_NUMBER_INVALID', message: 'PR number must be positive', retryable: false }
+            }),
+            reviews: []
+        };
+    }
+    const fetched = client.json(['api', '--paginate', '--slurp', `repos/${repository}/pulls/${prNumber}/reviews?per_page=100`], { cwd: options.cwd || process.cwd() });
+    if (!fetched.ok) {
+        return {
+            ...platformResult(fetched.error.retryable ? 'blocked' : 'failed', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: prNumber }, error: fetched.error
+            }),
+            reviews: []
+        };
+    }
+    const flat = (fetched.value || []).flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
+    const reviews = flat
+        .map((review) => ({
+        id: review.id ?? 0,
+        commitId: review.commit_id ?? '',
+        body: review.body ?? '',
+        url: review.html_url ?? ''
+    }))
+        .filter((review) => review.body !== '');
+    return {
+        ...platformResult('no-op', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: prNumber }, error: null
+        }),
+        reviews
+    };
+}
+export function publishPrReview(options) {
+    const client = options.client || createGitHubClient();
+    const context = resolvePlatformContext({ cwd: options.cwd || process.cwd(), client });
+    if (!hasUsableContext(context)) {
+        return platformResult(context.status, { platform: context.platform, capabilities: context.capabilities, error: context.error });
+    }
+    const repository = context.platform.repository;
+    if (invalidPrNumber(options.prNumber)) {
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            error: { code: 'PR_NUMBER_INVALID', message: 'PR number must be positive', retryable: false }
+        });
+    }
+    if (!REVIEW_EVENTS.includes(options.event)) {
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: options.prNumber },
+            error: { code: 'REVIEW_EVENT_INVALID', message: `review event must be one of ${REVIEW_EVENTS.join('|')}`, retryable: false }
+        });
+    }
+    if (!REVIEW_SCOPE_PATTERN.test(options.identity.scope) || !/^[0-9a-f]{7,40}$/i.test(options.identity.commitSha)) {
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: options.prNumber },
+            error: { code: 'REVIEW_IDENTITY_INVALID', message: 'review scope must be a task id or pr{N}; commitSha is required', retryable: false }
+        });
+    }
+    const marker = reviewMarker(options.identity);
+    const listed = listPrReviews(options.prNumber, { cwd: options.cwd, client });
+    if (listed.status === 'failed' || listed.status === 'blocked')
+        return listed;
+    const existing = listed.reviews.find((review) => firstLine(review.body) === marker) ?? null;
+    if (existing) {
+        if (existing.commitId === options.identity.commitSha) {
+            return platformResult('no-op', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: options.prNumber },
+                operations: [{ name: 'review:publish', status: 'no-op', reasonCode: null }], error: null
+            });
+        }
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: options.prNumber },
+            operations: [{ name: 'review:publish', status: 'failed', reasonCode: 'REVIEW_MARKER_CONFLICT' }],
+            error: { code: 'REVIEW_MARKER_CONFLICT', message: 'A review with the same marker targets a different commit; start a new round', retryable: false }
+        });
+    }
+    const wrappedBody = [
+        marker,
+        reviewedCommitMarker(options.identity.commitSha),
+        '',
+        String(options.body || '').replace(/\r?\n/g, '\n').replace(/\n+$/, ''),
+        ''
+    ].join('\n');
+    if (options.dryRun) {
+        return platformResult('planned', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: options.prNumber },
+            operations: [{ name: 'review:publish', status: 'planned', reasonCode: null }], error: null
+        });
+    }
+    const posted = client.json(['api', `repos/${repository}/pulls/${options.prNumber}/reviews`, '-X', 'POST', '--input', '-'], {
+        cwd: options.cwd || process.cwd(),
+        method: 'POST',
+        input: JSON.stringify({ commit_id: options.identity.commitSha, body: wrappedBody, event: options.event })
+    });
+    if (!posted.ok) {
+        if (posted.error.retryable) {
+            const reconciled = listPrReviews(options.prNumber, { cwd: options.cwd, client });
+            const found = reconciled.reviews.find((review) => firstLine(review.body) === marker);
+            if (found) {
+                return platformResult('applied', {
+                    changed: true, platform: context.platform, capabilities: context.capabilities,
+                    resource: { kind: 'pull-request', number: options.prNumber },
+                    operations: [{ name: 'review:publish', status: 'applied', reasonCode: 'CREATE_RECONCILED' }], error: null
+                });
+            }
+            return platformResult('blocked', {
+                platform: context.platform, capabilities: context.capabilities,
+                resource: { kind: 'pull-request', number: options.prNumber },
+                operations: [{ name: 'review:publish', status: 'failed', reasonCode: 'REVIEW_CREATE_OUTCOME_UNKNOWN' }],
+                error: { code: 'REVIEW_CREATE_OUTCOME_UNKNOWN', message: posted.error.message, retryable: true }
+            });
+        }
+        return platformResult('failed', {
+            platform: context.platform, capabilities: context.capabilities,
+            resource: { kind: 'pull-request', number: options.prNumber },
+            operations: [{ name: 'review:publish', status: 'failed', reasonCode: posted.error.code }], error: posted.error
+        });
+    }
+    return platformResult('applied', {
+        changed: true, platform: context.platform, capabilities: context.capabilities,
+        resource: { kind: 'pull-request', number: options.prNumber },
+        operations: [{ name: 'review:publish', status: 'applied', reasonCode: null }], error: null
+    });
+}
+//# sourceMappingURL=pr-review.js.map