@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/platform/release-notes.js

@@ -2,8 +2,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { resolvePlatformContext } from './context.js';
-import { fetchGitHubReleaseNoteData, publishGitHubReleaseNotes } from './github-release-notes.js';
+import { resolvePlatformProviderContext } from './context.js';
+import { providerError, providerOperationContext, providerStatus, unsupportedProviderOperation } from './provider-bridge.js';
+import { resourceIdentityNumber } from './resource-identity.js';
 const unsupportedError = {
     code: 'PLATFORM_RELEASE_NOTES_UNSUPPORTED',
     message: 'Release notes are not supported for the configured platform',
@@ -103,14 +104,21 @@ function configuredPlatform(cwd) {
         return null;
     }
 }
-function releaseNoteContext(input, options = {}) {
+async function releaseNoteContext(input, options = {}) {
     const historyLimit = input.historyLimit ?? 3;
     if (!input.fromTag || !input.toTag || !input.branch || !Number.isInteger(historyLimit) || historyLimit < 1 || historyLimit > 20) {
         return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_INPUT_INVALID', message: 'from-tag, to-tag, branch, and a history limit from 1 to 20 are required', retryable: false } };
     }
     const cwd = path.resolve(options.cwd || process.cwd());
     const platformType = options.platformType ?? configuredPlatform(cwd);
-    if (platformType !== 'github')
+    const loaded = await resolvePlatformProviderContext({ cwd, platformType: platformType || undefined, client: options.client });
+    if (!loaded.ok) {
+        if (loaded.context.status === 'no-op')
+            return baseResult('no-op');
+        const status = loaded.context.status === 'blocked' ? 'blocked' : 'failed';
+        return { ...baseResult(status), error: loaded.context.error };
+    }
+    if (!loaded.value.context.platform.repository)
         return baseResult('no-op');
     let fromOid;
     let toOid;
@@ -132,28 +140,24 @@ function releaseNoteContext(input, options = {}) {
     catch {
         return { ...baseResult('failed'), error: { code: 'RELEASE_NOTES_RANGE_INVALID', message: 'The release tag range is missing or is not ancestral', retryable: false } };
     }
-    const context = resolvePlatformContext({ cwd, platformType, client: options.client });
-    if (!context.platform.repository) {
-        return {
-            ...baseResult(context.status === 'blocked' ? 'blocked' : 'failed'),
-            error: context.error || { code: 'PLATFORM_CONTEXT_UNAVAILABLE', message: 'Platform repository is unavailable', retryable: context.status === 'blocked' }
-        };
-    }
-    const platform = fetchGitHubReleaseNoteData({
-        repository: context.platform.repository,
-        commitOids: commitFacts.map((item) => item.oid),
-        branch: input.branch,
-        historyLimit,
-        fromTime,
-        toTime
-    }, { cwd, client: options.client });
-    if (platform.status === 'blocked' || platform.status === 'failed' || !('authors' in platform)) {
-        return { ...baseResult(platform.status), error: platform.error };
-    }
+    const platform = loaded.value.provider.releases?.collectNotes
+        ? await loaded.value.provider.releases.collectNotes({
+            context: providerOperationContext(loaded.value),
+            commitOids: commitFacts.map((item) => item.oid),
+            branch: input.branch,
+            historyLimit,
+            fromTime,
+            toTime
+        })
+        : unsupportedProviderOperation(loaded.value.provider, 'releases.collectNotes');
+    if (!platform.ok)
+        return { ...baseResult(platform.error.retryable ? 'blocked' : 'failed'), error: providerError(platform.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
     const commits = commitFacts.map((commit) => {
         const seen = new Set();
-        const authors = (platform.authors.get(commit.oid) || []).filter((actor) => {
-            const key = actor.login || actor.email?.toLowerCase() || actor.name.toLowerCase();
+        const authors = platform.value.history.filter((item) => item.sha === commit.oid).flatMap((item) => item.author ? [item.author] : [])
+            .concat(platform.value.actors)
+            .filter((actor) => {
+            const key = actor.id || actor.name || '';
             if (seen.has(key))
                 return false;
             seen.add(key);
@@ -161,43 +165,37 @@ function releaseNoteContext(input, options = {}) {
         });
         return { ...commit, authors };
     });
-    const pullRequests = platform.pullRequests
+    const pullRequests = platform.value.mergedPullRequests
         .map((item) => ({
-        number: Number(item.number),
-        title: String(item.title || ''),
-        body: String(item.body || ''),
-        url: String(item.url || ''),
-        mergedAt: String(item.mergedAt || ''),
-        labels: Array.isArray(item.labels) ? item.labels.map((label) => String(label.name || label)) : [],
-        author: item.author && typeof item.author === 'object'
-            ? { login: String(item.author.login || '').toLowerCase(), bot: String(item.author.login || '').endsWith('[bot]') }
-            : null,
-        closingIssues: Array.isArray(item.closingIssuesReferences)
-            ? item.closingIssuesReferences.map((issue) => {
-                const value = issue;
-                return {
-                    number: Number(value.number),
-                    title: String(value.title || ''),
-                    url: String(value.url || ''),
-                    labels: Array.isArray(value.labels) ? value.labels.map((label) => String(label.name || label)) : [],
-                    author: value.author && typeof value.author === 'object'
-                        ? { login: String(value.author.login || '').toLowerCase(), bot: String(value.author.login || '').endsWith('[bot]') }
-                        : null
-                };
-            }) : []
+        number: item.number || resourceIdentityNumber(item.identity) || 0,
+        ...(item.identity ? { identity: item.identity } : {}),
+        title: item.title,
+        body: item.body,
+        url: item.displayUrl || '',
+        mergedAt: item.mergedAt || '',
+        labels: item.labels || [],
+        author: item.author ? { login: item.author.name || item.author.id || '', bot: false } : null,
+        closingIssues: platform.value.closingIssues.filter((issue) => issue.id === item.id).map((issue) => ({
+            number: issue.number || resourceIdentityNumber(issue.identity) || 0,
+            ...(issue.identity ? { identity: issue.identity } : {}),
+            title: issue.title,
+            url: issue.displayUrl || '',
+            labels: issue.labels || [],
+            author: issue.author ? { login: issue.author.name || issue.author.id || '', bot: false } : null
+        }))
     }))
         .sort((left, right) => left.number - right.number);
     return {
         status: 'no-op',
         changed: false,
         range: { fromTag: input.fromTag, toTag: input.toTag, fromOid, toOid },
-        history: platform.history,
+        history: platform.value.history,
         pullRequests,
         commits,
         error: null
     };
 }
-function publishReleaseNotes(input, options = {}) {
+async function publishReleaseNotes(input, options = {}) {
     if (!input.tag || !input.title || !input.notesFile || !SHA256_PATTERN.test(input.expectedSha256)) {
         return releaseNoteFailure('RELEASE_NOTES_INPUT_INVALID', 'tag, title, notes-file, and expected-sha256 are required');
     }
@@ -213,13 +211,38 @@ function publishReleaseNotes(input, options = {}) {
     }
     const cwd = path.resolve(options.cwd || process.cwd());
     const platformType = options.platformType ?? configuredPlatform(cwd);
-    if (platformType !== 'github')
-        return { status: 'no-op', changed: false, operation: null, url: null, error: unsupportedError };
-    const context = resolvePlatformContext({ cwd, platformType, client: options.client });
-    if (!context.platform.repository) {
-        return { status: context.status === 'blocked' ? 'blocked' : 'failed', changed: false, operation: null, url: null, error: context.error };
+    const loaded = await resolvePlatformProviderContext({ cwd, platformType: platformType || undefined, client: options.client });
+    if (!loaded.ok) {
+        const status = loaded.context.status === 'blocked'
+            ? 'blocked'
+            : loaded.context.status === 'no-op' ? 'no-op' : 'failed';
+        return {
+            ...baseResult(status),
+            error: loaded.context.error || { code: 'PLATFORM_PROVIDER_LOAD_FAILED', message: 'Selected provider failed to load', retryable: false }
+        };
     }
-    return publishGitHubReleaseNotes({ ...input, repository: context.platform.repository }, { cwd, client: options.client });
+    if (loaded.ok) {
+        const context = loaded.value.context;
+        if (!context.platform.repository)
+            return { status: context.status === 'blocked' ? 'blocked' : 'failed', changed: false, operation: null, url: null, error: context.error };
+        const published = loaded.value.provider.releases?.publishNotes
+            ? await loaded.value.provider.releases.publishNotes({
+                context: providerOperationContext(loaded.value),
+                release: { kind: 'key', value: input.tag },
+                title: input.title,
+                notes: {
+                    text: fs.readFileSync(input.notesFile, 'utf8'),
+                    sha256: actualSha256,
+                    byteLength: fs.statSync(input.notesFile).size
+                },
+                mutation: { idempotencyKey: `release-notes:publish:${input.tag}` }
+            })
+            : unsupportedProviderOperation(loaded.value.provider, 'releases.publishNotes');
+        if (!published.ok)
+            return { status: providerStatus(published.error), changed: false, operation: null, url: null, error: providerError(published.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
+        return { status: 'applied', changed: published.value.changed, operation: 'publish-notes', url: null, error: null };
+    }
+    return { status: 'failed', changed: false, operation: null, url: null, error: { code: 'PLATFORM_PROVIDER_LOAD_FAILED', message: 'Selected provider failed to load', retryable: false } };
 }
 export { normalizeReleaseNoteBytes, publishReleaseNotes, releaseNoteContext, releaseNoteSha256, stageReleaseNotes };
 //# sourceMappingURL=release-notes.js.map

package/dist/lib/platform/releases.js

@@ -1,57 +1,80 @@
-import { createGitHubClient } from './github-client.js';
-import { resolvePlatformContext } from './context.js';
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import { resolvePlatformProviderContext } from './context.js';
 import { platformResult } from './types.js';
+import { providerError, providerOperationContext, providerStatus, unsupportedProviderOperation } from './provider-bridge.js';
 function flattenPages(value) {
     if (!Array.isArray(value))
         return [];
     return value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]).filter((entry) => Boolean(entry) && typeof entry === 'object');
 }
-function inspectPlatformRelease(tag, options = {}) {
-    const client = options.client ?? createGitHubClient();
-    const context = resolvePlatformContext({ cwd: options.cwd, client });
+async function inspectPlatformRelease(tag, options = {}) {
+    const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
+    const context = loaded.ok ? loaded.value.context : loaded.context;
     if (!context.platform.repository)
         return { ...platformResult(context.status), platform: context.platform, release: null, workflows: [], error: context.error };
-    const result = client.json(['release', 'view', tag, '--repo', context.platform.repository, '--json', 'tagName,isDraft,url'], { cwd: options.cwd });
-    if (!result.ok) {
-        if (result.error.code === 'RESOURCE_NOT_FOUND')
-            return { ...platformResult('no-op'), platform: context.platform, release: null, workflows: [], error: null };
-        return { ...platformResult(result.error.retryable ? 'blocked' : 'failed'), platform: context.platform, release: null, workflows: [], error: result.error };
+    if (loaded.ok) {
+        const inspected = loaded.value.provider.releases?.inspect
+            ? await loaded.value.provider.releases.inspect({ context: providerOperationContext(loaded.value), tag })
+            : unsupportedProviderOperation(loaded.value.provider, 'releases.inspect');
+        if (!inspected.ok) {
+            if (inspected.error.code === 'RESOURCE_NOT_FOUND')
+                return { ...platformResult('no-op'), platform: context.platform, release: null, workflows: [], error: null };
+            return { ...platformResult(providerStatus(inspected.error)), platform: context.platform, release: null, workflows: [], error: providerError(inspected.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
+        }
+        return {
+            ...platformResult('no-op'),
+            platform: context.platform,
+            release: { tag: inspected.value.tag, published: !inspected.value.draft, draft: inspected.value.draft, url: inspected.value.displayUrl || null },
+            workflows: inspected.value.workflows || [],
+            error: null
+        };
     }
-    const release = { tag: String(result.value.tagName || tag), published: !Boolean(result.value.isDraft), draft: Boolean(result.value.isDraft), url: result.value.url ? String(result.value.url) : null };
-    const runs = client.json(['run', 'list', '--repo', context.platform.repository, '--limit', '100', '--json', 'name,workflowName,displayTitle,event,headBranch,headSha,status,conclusion,createdAt,databaseId,attempt,url'], { cwd: options.cwd });
-    return { ...platformResult(runs.ok ? 'no-op' : runs.error.retryable ? 'blocked' : 'degraded'), platform: context.platform, release, workflows: runs.ok ? runs.value : [], error: runs.ok ? null : runs.error };
+    return { ...platformResult('failed'), platform: context.platform, release: null, workflows: [], error: context.error };
 }
-function upsertPlatformRelease(input, options = {}) {
-    const inspected = inspectPlatformRelease(input.tag, options);
+async function upsertPlatformRelease(input, options = {}) {
+    const inspected = await inspectPlatformRelease(input.tag, options);
     if (inspected.release?.published)
         return { ...inspected, status: 'no-op', changed: false, operations: [] };
     if (inspected.status === 'blocked' || inspected.status === 'failed')
         return { ...inspected, changed: false, operations: [] };
     if (!inspected.platform.repository)
         return { ...inspected, status: 'no-op', changed: false, operations: [] };
-    const client = options.client ?? createGitHubClient();
-    const args = ['release', 'create', input.tag, '--repo', inspected.platform.repository, '--title', input.title ?? input.tag];
-    if (input.notesFile)
-        args.push('--notes-file', input.notesFile);
-    else
-        args.push('--generate-notes');
-    const created = client.text(args, { cwd: options.cwd, method: 'POST' });
-    if (!created.ok)
-        return { ...inspected, status: created.error.retryable ? 'blocked' : 'failed', changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: created.error };
-    return { ...inspectPlatformRelease(input.tag, options), status: 'applied', changed: true, operations: [{ name: 'create-release', status: 'applied' }] };
+    const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
+    if (loaded.ok) {
+        let notes;
+        if (input.notesFile) {
+            try {
+                const bytes = fs.readFileSync(input.notesFile);
+                notes = { text: bytes.toString('utf8'), sha256: `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`, byteLength: bytes.byteLength };
+            }
+            catch {
+                return { ...inspected, status: 'failed', changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: { code: 'RELEASE_NOTES_FILE_UNREADABLE', message: 'notes-file could not be read', retryable: false } };
+            }
+        }
+        const created = loaded.value.provider.releases?.create
+            ? await loaded.value.provider.releases.create({
+                context: providerOperationContext(loaded.value),
+                tag: input.tag,
+                title: input.title ?? input.tag,
+                ...(notes ? { notes } : {}),
+                mutation: { idempotencyKey: `release:create:${input.tag}` }
+            })
+            : unsupportedProviderOperation(loaded.value.provider, 'releases.create');
+        if (!created.ok)
+            return { ...inspected, status: providerStatus(created.error), changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: providerError(created.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
+        return { ...inspected, status: 'applied', changed: created.value.changed, operations: [{ name: 'create-release', status: 'applied' }], error: null };
+    }
+    return { ...inspected, status: 'failed', changed: false, operations: [{ name: 'create-release', status: 'failed' }], error: { code: 'PLATFORM_PROVIDER_LOAD_FAILED', message: 'Selected provider failed to load', retryable: false } };
 }
-function reconcileReleaseMilestones(version, options = {}) {
+async function reconcileReleaseMilestones(version, options = {}) {
     const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
     if (!match)
         return { status: 'failed', changed: false, operations: [], error: { code: 'RELEASE_VERSION_INVALID', message: `Invalid version '${version}'` } };
-    const client = options.client ?? createGitHubClient();
-    const context = resolvePlatformContext({ cwd: options.cwd, client });
+    const loaded = await resolvePlatformProviderContext({ cwd: options.cwd, client: options.client });
+    const context = loaded.ok ? loaded.value.context : loaded.context;
     if (!context.platform.repository)
         return { ...platformResult(context.status), changed: false, operations: [], error: context.error };
-    const listed = client.json(['api', '--paginate', '--slurp', `repos/${context.platform.repository}/milestones?state=all&per_page=100`], { cwd: options.cwd });
-    if (!listed.ok)
-        return { ...platformResult(listed.error.retryable ? 'blocked' : 'failed'), changed: false, operations: [], error: listed.error };
-    const milestones = flattenPages(listed.value).map((item) => ({ title: String(item.title || ''), number: Number(item.number), state: String(item.state || '') }));
     const major = Number(match[1]);
     const minor = Number(match[2]);
     const patch = Number(match[3]);
@@ -66,25 +89,31 @@ function reconcileReleaseMilestones(version, options = {}) {
         const nextLine = `${major}.${minor + 1}.x`;
         ensure.push({ title: nextMinor, description: `Issues that we want to release in v${nextMinor}.` }, { title: nextLine, description: `Issues that we want to resolve in ${major}.${minor + 1} line.` });
     }
-    const operations = [];
-    const current = milestones.find((item) => item.title === version);
-    if (current && current.state !== 'closed') {
-        const closed = client.json(['api', '--method', 'PATCH', `repos/${context.platform.repository}/milestones/${current.number}`, '-f', 'state=closed'], { cwd: options.cwd });
-        operations.push({ name: 'close-milestone', title: version, status: closed.ok ? 'applied' : 'failed' });
-    }
-    else
-        operations.push({ name: 'close-milestone', title: version, status: 'no-op' });
-    for (const { title, description } of ensure) {
-        if (milestones.some((item) => item.title === title))
-            operations.push({ name: 'ensure-milestone', title, status: 'no-op' });
-        else {
-            const created = client.json(['api', '--method', 'POST', `repos/${context.platform.repository}/milestones`, '-f', `title=${title}`, '-f', `description=${description}`], { cwd: options.cwd });
-            operations.push({ name: 'ensure-milestone', title, status: created.ok ? 'applied' : 'failed' });
-        }
+    if (loaded.ok) {
+        const reconciled = loaded.value.provider.releases?.reconcileMilestones
+            ? await loaded.value.provider.releases.reconcileMilestones({
+                context: providerOperationContext(loaded.value),
+                version,
+                desired: [
+                    { key: version, title: version, description: `Issues that we want to resolve in v${version}.`, state: 'closed' },
+                    ...ensure.map((item) => ({ key: item.title, title: item.title, description: item.description, state: 'open' }))
+                ],
+                mutation: { idempotencyKey: `milestones:reconcile:${version}` }
+            })
+            : unsupportedProviderOperation(loaded.value.provider, 'releases.reconcileMilestones');
+        if (!reconciled.ok)
+            return { status: providerStatus(reconciled.error), changed: false, operations: [], error: providerError(reconciled.error, 'PLATFORM_PROVIDER_OPERATION_FAILED') };
+        return {
+            status: reconciled.value.changed ? 'applied' : 'no-op',
+            changed: reconciled.value.changed,
+            operations: [
+                ...reconciled.value.closed.map((title) => ({ name: 'close-milestone', title, status: 'applied' })),
+                ...reconciled.value.created.map((title) => ({ name: 'ensure-milestone', title, status: 'applied' }))
+            ],
+            error: null
+        };
     }
-    const failed = operations.some((operation) => operation.status === 'failed');
-    const changed = operations.some((operation) => operation.status === 'applied');
-    return { status: failed ? 'failed' : changed ? 'applied' : 'no-op', changed, operations, error: failed ? { code: 'MILESTONE_RECONCILE_FAILED', message: 'One or more milestone operations failed' } : null };
+    return { status: 'failed', changed: false, operations: [], error: { code: 'PLATFORM_CAPABILITY_UNSUPPORTED', message: 'Release milestone reconciliation is unavailable', retryable: false } };
 }
 export { inspectPlatformRelease, reconcileReleaseMilestones, upsertPlatformRelease };
 //# sourceMappingURL=releases.js.map