@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/task/pr-delivery-fact.js

@@ -1,182 +1,183 @@
+import { isLegacyCompatibilityEnabled, legacyCompatibilityError, VERSION } from '../version.js';
+import { isResourceIdentity, parseResourceIdentity, resourceIdentityNumber, serializeResourceIdentity } from '../platform/resource-identity.js';
 const PR_DELIVERY_FACT_KEY = 'pr_delivery_fact';
 function factError(message) {
     return Object.assign(new Error(`PR_DELIVERY_FACT_INVALID: ${message}`), { code: 'PR_DELIVERY_FACT_INVALID' });
 }
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+function asFactError(error) {
+    if (error instanceof Error && typeof error.code === 'string')
+        return error;
+    return factError(error instanceof Error ? error.message : String(error));
 }
+function isRecord(value) { return Boolean(value) && typeof value === 'object' && !Array.isArray(value); }
 function exactKeys(value, keys, label) {
     const actual = Object.keys(value).sort();
     const expected = [...keys].sort();
-    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index]))
         throw factError(`${label} has an invalid field set`);
-    }
 }
-function text(value, label) {
-    if (typeof value !== 'string' || !value || value.trim() !== value)
-        throw factError(`${label} must be a non-empty string`);
+function text(value, label, allowEmpty = false) {
+    if (typeof value !== 'string' || (!allowEmpty && !value) || value.trim() !== value)
+        throw factError(`${label} must be a string`);
     return value;
 }
-function nullableText(value, label) {
-    return value === null ? null : text(value, label);
+function nullableText(value, label) { return value === null ? null : text(value, label); }
+function timestamp(value, label) {
+    const result = text(value, label);
+    if (Number.isNaN(Date.parse(result)))
+        throw factError(`${label} must be a valid timestamp`);
+    return new Date(result).toISOString();
 }
 function positiveNumber(value, label) {
     if (!Number.isSafeInteger(value) || value <= 0)
         throw factError(`${label} must be a positive integer`);
     return value;
 }
-function optionalTimestamp(value, label) {
-    const result = nullableText(value, label);
-    if (result !== null && Number.isNaN(Date.parse(result)))
-        throw factError(`${label} must be a valid timestamp`);
-    return result;
+function parseRef(value, label) {
+    if (!isRecord(value))
+        throw factError(`${label} must be an object`);
+    exactKeys(value, ['repository', 'ref', 'sha'], label);
+    return { repository: text(value.repository, `${label}.repository`), ref: text(value.ref, `${label}.ref`), sha: text(value.sha, `${label}.sha`) };
 }
-function parseIdentity(value) {
+function canonicalIdentity(value) {
     if (!isRecord(value))
         throw factError('identity must be an object');
-    exactKeys(value, ['repository', 'number', 'nodeId', 'url', 'head', 'base'], 'identity');
-    const head = parseRef(value.head, 'head');
-    const base = parseRef(value.base, 'base');
+    exactKeys(value, ['resource', 'repository', 'url', 'head', 'base'], 'identity');
     return {
+        resource: parseResourceIdentity(value.resource, 'identity.resource'),
         repository: text(value.repository, 'identity.repository'),
-        number: positiveNumber(value.number, 'identity.number'),
-        nodeId: text(value.nodeId, 'identity.nodeId'),
         url: text(value.url, 'identity.url'),
-        head,
-        base
+        head: parseRef(value.head, 'identity.head'),
+        base: parseRef(value.base, 'identity.base')
     };
 }
-function parseRef(value, label) {
+function decodeLegacyIdentity(value) {
     if (!isRecord(value))
-        throw factError(`${label} must be an object`);
-    exactKeys(value, ['repository', 'ref', 'sha'], label);
+        throw factError('legacy identity must be an object');
+    // TODO(compat): Remove the v1 identity decoder before the first stable v1.0.0 release.
+    exactKeys(value, ['repository', 'number', 'nodeId', 'url', 'head', 'base'], 'legacy identity');
+    const legacy = {
+        number: positiveNumber(value.number, 'legacy identity.number'),
+        repository: text(value.repository, 'identity.repository'),
+        nodeId: text(value.nodeId, 'legacy identity.nodeId'),
+        url: text(value.url, 'identity.url'),
+        head: parseRef(value.head, 'identity.head'),
+        base: parseRef(value.base, 'identity.base')
+    };
     return {
-        repository: text(value.repository, `${label}.repository`),
-        ref: text(value.ref, `${label}.ref`),
-        sha: text(value.sha, `${label}.sha`)
+        resource: { kind: 'number', value: legacy.number },
+        repository: legacy.repository,
+        url: legacy.url,
+        head: legacy.head,
+        base: legacy.base
     };
 }
-function parseFact(value) {
+function provenanceForSource(source) { return source === 'created' ? 'create-post' : source === 'reused' ? 'reuse' : source; }
+function parseFact(value, runtimeVersion = VERSION) {
     if (!isRecord(value))
         throw factError('fact must be an object');
-    if (value.version !== 1 || typeof value.state !== 'string')
+    if ((value.version !== 1 && value.version !== 2) || typeof value.state !== 'string')
         throw factError('version or state is invalid');
+    if (value.version === 1 && !isLegacyCompatibilityEnabled(runtimeVersion)) {
+        throw legacyCompatibilityError('v1 PR delivery fact', runtimeVersion);
+    }
     if (value.state === 'unbound') {
         exactKeys(value, ['version', 'state', 'reason'], 'unbound fact');
         if (value.reason !== 'initial')
             throw factError('unbound reason is invalid');
-        return { version: 1, state: 'unbound', reason: value.reason };
+        return { version: 2, state: 'unbound', reason: 'initial' };
     }
     if (value.state === 'skipped') {
         exactKeys(value, ['version', 'state', 'reason', 'decidedAt'], 'skipped fact');
         if (value.reason !== 'explicit')
             throw factError('skipped reason is invalid');
-        const decidedAt = text(value.decidedAt, 'skipped.decidedAt');
-        if (Number.isNaN(Date.parse(decidedAt)))
-            throw factError('skipped.decidedAt must be a valid timestamp');
-        return { version: 1, state: 'skipped', reason: 'explicit', decidedAt };
+        return { version: 2, state: 'skipped', reason: 'explicit', decidedAt: timestamp(value.decidedAt, 'skipped.decidedAt') };
     }
     if (value.state !== 'bound')
         throw factError('state is invalid');
+    if (value.version === 1) {
+        // TODO(compat): Remove this v1-to-v2 shape conversion before the first stable v1.0.0 release.
+        exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'legacy bound fact');
+        if (!isRecord(value.binding) || !isRecord(value.provenance))
+            throw factError('legacy binding or provenance is invalid');
+        exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueNumber', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'legacy binding');
+        const issueNumber = value.binding.issueNumber === null ? null : positiveNumber(value.binding.issueNumber, 'legacy binding.issueNumber');
+        return parseFact({
+            version: 2,
+            state: 'bound',
+            identity: decodeLegacyIdentity(value.identity),
+            binding: {
+                status: 'verified', source: value.binding.source, verifiedAt: timestamp(value.binding.verifiedAt, 'binding.verifiedAt'),
+                issueIdentity: issueNumber === null ? null : { kind: 'number', value: issueNumber }, remoteState: value.binding.remoteState,
+                mergedAt: value.binding.mergedAt === null ? null : timestamp(value.binding.mergedAt, 'binding.mergedAt'), mergeCommitSha: nullableText(value.binding.mergeCommitSha, 'binding.mergeCommitSha')
+            },
+            provenance: value.provenance
+        }, runtimeVersion);
+    }
     exactKeys(value, ['version', 'state', 'identity', 'binding', 'provenance'], 'bound fact');
-    if (!isRecord(value.binding))
-        throw factError('binding must be an object');
-    exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueNumber', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'binding');
+    if (!isRecord(value.binding) || !isRecord(value.provenance))
+        throw factError('binding or provenance is invalid');
+    exactKeys(value.binding, ['status', 'source', 'verifiedAt', 'issueIdentity', 'remoteState', 'mergedAt', 'mergeCommitSha'], 'binding');
     if (value.binding.status !== 'verified')
         throw factError('binding status is invalid');
     const sources = ['created', 'reused', 'explicit-bind', 'external-unique', 'external-explicit'];
     if (!sources.includes(value.binding.source))
         throw factError('binding source is invalid');
-    const verifiedAt = text(value.binding.verifiedAt, 'binding.verifiedAt');
-    if (Number.isNaN(Date.parse(verifiedAt)))
-        throw factError('binding.verifiedAt must be a valid timestamp');
-    const issueNumber = value.binding.issueNumber === null ? null : positiveNumber(value.binding.issueNumber, 'binding.issueNumber');
+    const issueIdentity = value.binding.issueIdentity === null ? null : parseResourceIdentity(value.binding.issueIdentity, 'binding.issueIdentity');
     if (value.binding.remoteState !== 'open' && value.binding.remoteState !== 'closed')
         throw factError('binding.remoteState is invalid');
-    const mergedAt = optionalTimestamp(value.binding.mergedAt, 'binding.mergedAt');
+    const mergedAt = value.binding.mergedAt === null ? null : timestamp(value.binding.mergedAt, 'binding.mergedAt');
     const mergeCommitSha = nullableText(value.binding.mergeCommitSha, 'binding.mergeCommitSha');
     if (Boolean(mergedAt) !== Boolean(mergeCommitSha))
         throw factError('mergedAt and mergeCommitSha must be paired');
-    if (!isRecord(value.provenance))
-        throw factError('provenance must be an object');
     exactKeys(value.provenance, ['establishedBy'], 'provenance');
-    const provenance = ['create-post', 'reuse', 'explicit-bind', 'external-unique', 'external-explicit'];
-    if (!provenance.includes(value.provenance.establishedBy))
+    const provenances = ['create-post', 'reuse', 'explicit-bind', 'external-unique', 'external-explicit'];
+    if (!provenances.includes(value.provenance.establishedBy))
         throw factError('provenance.establishedBy is invalid');
-    if (value.provenance.establishedBy !== provenanceForSource(value.binding.source)) {
+    if (value.provenance.establishedBy !== provenanceForSource(value.binding.source))
         throw factError('binding.source and provenance.establishedBy do not match');
-    }
     return {
-        version: 1,
-        state: 'bound',
-        identity: parseIdentity(value.identity),
-        binding: {
-            status: 'verified',
-            source: value.binding.source,
-            verifiedAt,
-            issueNumber,
-            remoteState: value.binding.remoteState,
-            mergedAt,
-            mergeCommitSha
-        },
+        version: 2, state: 'bound', identity: canonicalIdentity(value.identity),
+        binding: { status: 'verified', source: value.binding.source, verifiedAt: timestamp(value.binding.verifiedAt, 'binding.verifiedAt'), issueIdentity, remoteState: value.binding.remoteState, mergedAt, mergeCommitSha },
         provenance: { establishedBy: value.provenance.establishedBy }
     };
 }
-function decodePrDeliveryFact(value) {
+function decodePrDeliveryFact(value, runtimeVersion = VERSION) {
     if (typeof value === 'string') {
+        let decoded;
         try {
-            return parseFact(JSON.parse(value));
+            decoded = JSON.parse(value);
         }
-        catch (error) {
-            throw error instanceof Error && error.message.startsWith('PR_DELIVERY_FACT_INVALID:') ? error : factError('value is not valid JSON');
+        catch {
+            throw factError('value is not valid JSON');
         }
+        return parseFact(decoded, runtimeVersion);
     }
-    return parseFact(value);
+    return parseFact(value, runtimeVersion);
 }
-function encodePrDeliveryFact(fact) {
-    return JSON.stringify(parseFact(fact));
-}
-function readPrDeliveryFact(metadata) {
+function encodePrDeliveryFact(fact) { return JSON.stringify(parseFact(fact)); }
+function readPrDeliveryFact(metadata, runtimeVersion = VERSION) {
     if (!Object.hasOwn(metadata, PR_DELIVERY_FACT_KEY) || metadata[PR_DELIVERY_FACT_KEY] === '')
         return { status: 'missing', fact: null };
     try {
-        return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY]) };
+        return { status: 'valid', fact: decodePrDeliveryFact(metadata[PR_DELIVERY_FACT_KEY], runtimeVersion) };
     }
     catch (error) {
-        return { status: 'invalid', fact: null, error: error instanceof Error ? error : factError(String(error)) };
+        return { status: 'invalid', fact: null, error: asFactError(error) };
     }
 }
-function buildUnboundFact() {
-    return { version: 1, state: 'unbound', reason: 'initial' };
-}
-function buildSkippedFact(decidedAt) {
-    return parseFact({ version: 1, state: 'skipped', reason: 'explicit', decidedAt });
-}
-function provenanceForSource(source) {
-    return source === 'created' ? 'create-post' : source === 'reused' ? 'reuse' : source;
-}
+function buildUnboundFact() { return { version: 2, state: 'unbound', reason: 'initial' }; }
+function buildSkippedFact(decidedAt) { return parseFact({ version: 2, state: 'skipped', reason: 'explicit', decidedAt }); }
 function buildBoundFact(input) {
-    return parseFact({
-        version: 1,
-        state: 'bound',
-        identity: input.identity,
-        binding: {
-            status: 'verified',
-            source: input.source,
-            verifiedAt: input.verifiedAt,
-            issueNumber: input.issueNumber ?? null,
-            remoteState: input.remoteState,
-            mergedAt: input.mergedAt ?? null,
-            mergeCommitSha: input.mergeCommitSha ?? null
-        },
-        provenance: { establishedBy: provenanceForSource(input.source) }
-    });
-}
-function factFrontmatterMutation(fact) {
-    return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } };
+    return parseFact({ version: 2, state: 'bound', identity: input.identity, binding: {
+            status: 'verified', source: input.source, verifiedAt: input.verifiedAt,
+            issueIdentity: input.issueIdentity === undefined ? null : input.issueIdentity,
+            remoteState: input.remoteState, mergedAt: input.mergedAt ?? null, mergeCommitSha: input.mergeCommitSha ?? null
+        }, provenance: { establishedBy: provenanceForSource(input.source) } });
 }
+function factFrontmatterMutation(fact) { return { set: { [PR_DELIVERY_FACT_KEY]: encodePrDeliveryFact(fact) } }; }
 function identityFromPullRequest(pullRequest) {
-    return parseIdentity(pullRequest);
+    return canonicalIdentity(pullRequest);
 }
-export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact };
+export { PR_DELIVERY_FACT_KEY, buildBoundFact, buildSkippedFact, buildUnboundFact, decodePrDeliveryFact, encodePrDeliveryFact, factFrontmatterMutation, identityFromPullRequest, readPrDeliveryFact, serializeResourceIdentity };
 //# sourceMappingURL=pr-delivery-fact.js.map