@fitlab-ai/agent-infra 0.9.12 → 0.9.13

package/dist/lib/platform/in-label-sync.js

@@ -0,0 +1,143 @@
+import { computeInLabels } from './metadata-labels.js';
+function inLabels(labels) {
+    return [...new Set(labels.filter((label) => label.startsWith('in:')))].sort();
+}
+function mergeInLabels(labels, target) {
+    return [...new Set([
+            ...labels.filter((label) => !label.startsWith('in:')),
+            ...target
+        ])].sort();
+}
+function invalidInLabelInput(code, message) {
+    return { ok: false, error: { code, message, retryable: false } };
+}
+function validateInLabelMapping(value) {
+    if (value === undefined)
+        return { ok: true, value: {} };
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return invalidInLabelInput('IN_LABEL_SYNC_MAPPING_INVALID', 'labels.in must be an object of non-empty string arrays');
+    }
+    const normalized = {};
+    for (const [name, rawPrefixes] of Object.entries(value)) {
+        if (!name.trim() || !Array.isArray(rawPrefixes) || rawPrefixes.length === 0 || rawPrefixes.some((prefix) => typeof prefix !== 'string' || !prefix.trim())) {
+            return invalidInLabelInput('IN_LABEL_SYNC_MAPPING_INVALID', `labels.in entry '${name}' must be a non-empty string array`);
+        }
+        normalized[name] = rawPrefixes.map((prefix) => prefix.trim());
+    }
+    return { ok: true, value: normalized };
+}
+function repositoryLabelPages(value) {
+    if (!Array.isArray(value))
+        return null;
+    if (value.length === 0)
+        return [];
+    if (value.every((page) => Array.isArray(page)))
+        return value;
+    if (value.every((entry) => entry && typeof entry === 'object' && !Array.isArray(entry)))
+        return [value];
+    return null;
+}
+function validateRepositoryLabelPayload(value) {
+    const pages = repositoryLabelPages(value);
+    if (!pages)
+        return invalidInLabelInput('IN_LABEL_SYNC_LABELS_INVALID', 'Repository labels response must be an array of pages');
+    const names = [];
+    for (const page of pages) {
+        for (const entry of page) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry) || typeof entry.name !== 'string' || !entry.name.trim()) {
+                return invalidInLabelInput('IN_LABEL_SYNC_LABELS_INVALID', 'Repository labels response contains an entry without a valid name');
+            }
+            names.push(entry.name);
+        }
+    }
+    return { ok: true, value: [...new Set(names)].sort() };
+}
+function validateRepositoryLabelSet(value) {
+    if (!(value instanceof Set) || [...value].some((label) => typeof label !== 'string' || !label.trim())) {
+        return invalidInLabelInput('IN_LABEL_SYNC_LABELS_INVALID', 'Repository labels must be a set of non-empty names');
+    }
+    return { ok: true, value: new Set([...value]) };
+}
+function planInLabelUpdate(input) {
+    const current = inLabels(input.currentLabels);
+    const mapping = validateInLabelMapping(input.mapping);
+    const repositoryLabels = validateRepositoryLabelSet(input.repositoryLabels);
+    if (!mapping.ok)
+        return { current, target: [...current], labels: [...input.currentLabels].sort(), changed: false, error: mapping.error };
+    if (!repositoryLabels.ok)
+        return { current, target: [...current], labels: [...input.currentLabels].sort(), changed: false, error: repositoryLabels.error };
+    const target = computeInLabels([...input.changedFiles], mapping.value, repositoryLabels.value);
+    const labels = mergeInLabels(input.currentLabels, target);
+    return { current, target, labels, changed: labels.join('\0') !== [...input.currentLabels].sort().join('\0'), error: null };
+}
+function startsWithPrefix(label, prefix) {
+    return (Array.isArray(prefix) ? prefix : [prefix]).some((value) => label.startsWith(value));
+}
+function labelDelta(current, target, prefix = 'in:') {
+    const currentLabels = [...new Set(current)].sort();
+    const targetLabels = [...new Set(target.filter((label) => startsWithPrefix(label, prefix)))].sort();
+    return {
+        add: targetLabels.filter((label) => !currentLabels.includes(label)),
+        remove: currentLabels.filter((label) => startsWithPrefix(label, prefix) && !targetLabels.includes(label))
+    };
+}
+function syncLabelDelta(client, repository, number, cwd, current, target, prefix = 'in:') {
+    const delta = labelDelta(current, target, prefix);
+    let changed = false;
+    const failure = (error) => {
+        if (changed || error.retryable) {
+            return {
+                status: 'blocked',
+                changed,
+                error: { ...error, code: 'IN_LABEL_SYNC_PARTIAL', message: `In-label synchronization is partial or unknown: ${error.message}` }
+            };
+        }
+        return { status: 'failed', changed: false, error };
+    };
+    for (const label of delta.remove) {
+        const removed = client.json([
+            'api', `repos/${repository}/issues/${number}/labels/${encodeURIComponent(label)}`, '-X', 'DELETE'
+        ], { cwd, method: 'DELETE' });
+        if (!removed.ok)
+            return failure(removed.error);
+        changed = true;
+    }
+    for (const label of delta.add) {
+        const added = client.json([
+            'api', `repos/${repository}/issues/${number}/labels`, '-X', 'POST', '--input', '-'
+        ], { cwd, method: 'POST', input: JSON.stringify({ labels: [label] }) });
+        if (!added.ok)
+            return failure(added.error);
+        changed = true;
+    }
+    return { status: changed ? 'applied' : 'no-op', changed, error: null };
+}
+function flattenPages(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((page) => Array.isArray(page) ? page : [page]);
+}
+function extractRepositoryLabelNames(value) {
+    return flattenPages(value).flatMap((entry) => {
+        if (typeof entry === 'string')
+            return [entry];
+        if (entry && typeof entry === 'object' && typeof entry.name === 'string') {
+            return [entry.name];
+        }
+        return [];
+    }).filter(Boolean).sort();
+}
+function extractPullRequestFileNames(value) {
+    const entries = flattenPages(value);
+    if (!Array.isArray(value) || entries.some((entry) => !entry || typeof entry !== 'object'))
+        return null;
+    const names = entries.map((entry) => entry.filename);
+    if (names.some((name) => typeof name !== 'string' || !name.trim()))
+        return null;
+    return [...new Set(names)].sort();
+}
+function resourceSnapshot(kind, number, labels) {
+    return { kind, number, labels: [...labels].sort() };
+}
+export { extractPullRequestFileNames, extractRepositoryLabelNames, flattenPages, inLabels, labelDelta, mergeInLabels, planInLabelUpdate, resourceSnapshot, syncLabelDelta, validateInLabelMapping, validateRepositoryLabelPayload };
+//# sourceMappingURL=in-label-sync.js.map

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

@@ -2,9 +2,14 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parseTaskFrontmatter } from '../task/frontmatter.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
-import { createGitHubClient } from './github-client.js';
-import { resolvePlatformContext } from './context.js';
+import { resolvePlatformProviderContext } from './context.js';
 import { platformResult } from './types.js';
+import { providerError, providerOperationContext, providerStatus, providerResourceToken, unsupportedProviderOperation } from './provider-bridge.js';
+import { resourceIdentityNumber } from './resource-identity.js';
+import { taskIssueIdentity, taskIssueIdentityError } from './task-identities.js';
+function providerCommentId(id, provider) {
+    return provider.identity?.comment === 'number' && /^\d+$/.test(id) ? Number(id) : id;
+}
 const MARKERS = {
     task: (taskId) => `<!-- sync-issue:${taskId}:task -->`,
     artifact: (taskId, stem) => `<!-- sync-issue:${taskId}:${stem} -->`,
@@ -137,7 +142,7 @@ function flattenComments(value) {
     if (!Array.isArray(value))
         return [];
     const flattened = value.flatMap((entry) => Array.isArray(entry) ? entry : [entry]);
-    return flattened.filter((entry) => Boolean(entry && typeof entry === 'object' && typeof entry.id === 'number' && typeof entry.body === 'string'));
+    return flattened.filter((entry) => Boolean(entry && typeof entry === 'object' && (typeof entry.id === 'number' || typeof entry.id === 'string') && typeof entry.body === 'string'));
 }
 function issueNumberFromTask(content) {
     const value = parseTaskFrontmatter(content).issue_number;
@@ -246,7 +251,7 @@ function writeComment(client, repo, issue, cwd, body, id) {
     const endpoint = id ? `repos/${repo}/issues/comments/${id}` : `repos/${repo}/issues/${issue}/comments`;
     return client.json(['api', endpoint, '-X', id ? 'PATCH' : 'POST', '--input', '-'], { cwd, method: id ? 'PATCH' : 'POST', input: JSON.stringify({ body }) });
 }
-function syncPlatformComment(taskRef, options) {
+async function syncPlatformComment(taskRef, options) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok) {
         return platformResult('failed', {
@@ -254,17 +259,35 @@ function syncPlatformComment(taskRef, options) {
         });
     }
     const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    const issue = issueNumberFromTask(taskContent);
-    if (!issue) {
+    let issueIdentityFromTask;
+    try {
+        issueIdentityFromTask = taskIssueIdentity(parseTaskFrontmatter(taskContent), undefined, options.runtimeVersion);
+    }
+    catch (error) {
+        return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } });
+    }
+    if (!issueIdentityFromTask) {
         return platformResult('no-op', {
             error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false }
         });
     }
-    const context = resolvePlatformContext({ cwd: resolved.repoRoot, client: options.client });
-    if (!hasResolvedPlatformContext(context))
+    const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
+    const context = loaded.ok ? loaded.value.context : loaded.context;
+    if (!hasResolvedPlatformContext(context) || !loaded.ok)
         return context;
-    const client = options.client || createGitHubClient();
-    const listed = listRemoteComments(client, context.platform.repository, issue, resolved.repoRoot);
+    const issue = resourceIdentityNumber(issueIdentityFromTask);
+    const listed = loaded.value.provider.comments?.list
+        ? await loaded.value.provider.comments.list({
+            context: providerOperationContext(loaded.value),
+            parent: issueIdentityFromTask
+        }).then((response) => response.ok
+            ? { ok: true, value: response.value.map((comment) => ({
+                    id: providerCommentId(comment.id, loaded.value.provider),
+                    body: comment.body,
+                    user: comment.author?.name ? { login: comment.author.name } : undefined
+                })) }
+            : response)
+        : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
     if (!listed.ok) {
         return platformResult(listed.error.retryable ? 'blocked' : 'failed', {
             ...contextFields(context), resource: { kind: 'issue', number: issue }, error: listed.error
@@ -310,7 +333,6 @@ function syncPlatformComment(taskRef, options) {
             error: null
         });
     }
-    const repo = context.platform.repository;
     const operations = [];
     const ids = [];
     for (const item of desired) {
@@ -320,16 +342,18 @@ function syncPlatformComment(taskRef, options) {
             operations.push({ name: `comment:${item.marker}`, status: 'no-op', reasonCode: null });
             continue;
         }
-        const written = writeComment(client, repo, issue, resolved.repoRoot, item.body, current?.id);
+        const written = loaded.value.provider.comments?.write
+            ? await loaded.value.provider.comments.write({
+                context: providerOperationContext(loaded.value),
+                parent: issueIdentityFromTask,
+                body: item.body,
+                ...(current ? { existingComment: { kind: 'id', value: String(current.id) } } : {}),
+                mutation: { idempotencyKey: `comment:${resolved.taskId}:${item.marker}` }
+            })
+            : unsupportedProviderOperation(loaded.value.provider, 'comments.write');
         if (!written.ok) {
             if (!current && written.error.retryable) {
-                const reconciled = listRemoteComments(client, repo, issue, resolved.repoRoot);
-                const found = reconciled.ok ? findMarkerComments(reconciled.value, item.marker) : [];
-                if (found.length === 1) {
-                    ids.push(found[0].id);
-                    operations.push({ name: `comment:${item.marker}`, status: 'applied', reasonCode: 'CREATE_RECONCILED' });
-                    continue;
-                }
+                // A provider owns reconciliation because only it knows how to address the resource.
             }
             return platformResult(written.error.retryable ? 'blocked' : 'failed', {
                 ...contextFields(context),
@@ -338,15 +362,20 @@ function syncPlatformComment(taskRef, options) {
                 error: written.error
             });
         }
-        ids.push(current?.id || written.value.id || 0);
+        ids.push(providerCommentId(written.value.remoteId, loaded.value.provider));
         operations.push({ name: `comment:${item.marker}`, status: 'applied', reasonCode: null });
     }
     const desiredMarkers = new Set(desired.map((item) => item.marker));
     const stale = existing.filter((comment) => !desiredMarkers.has(normalizeCommentContent(comment.body).split('\n', 1)[0]));
     for (const comment of stale) {
-        const deleted = client.text(['api', `repos/${repo}/issues/comments/${comment.id}`, '-X', 'DELETE'], {
-            cwd: resolved.repoRoot, method: 'DELETE'
-        });
+        const deleted = loaded.value.provider.comments?.delete
+            ? await loaded.value.provider.comments.delete({
+                context: providerOperationContext(loaded.value),
+                parent: issueIdentityFromTask,
+                comment: { kind: 'id', value: String(comment.id) },
+                mutation: { idempotencyKey: `comment-delete:${resolved.taskId}:${comment.id}` }
+            })
+            : unsupportedProviderOperation(loaded.value.provider, 'comments.delete');
         if (!deleted.ok) {
             return platformResult(deleted.error.retryable ? 'blocked' : 'failed', {
                 ...contextFields(context),
@@ -367,31 +396,55 @@ function syncPlatformComment(taskRef, options) {
         error: null
     });
 }
-function listPlatformComments(issue, cwd = process.cwd(), client = createGitHubClient()) {
-    const context = resolvePlatformContext({ cwd, client });
-    if (!hasResolvedPlatformContext(context))
+async function listPlatformComments(issue, cwd = process.cwd(), client) {
+    const loaded = await resolvePlatformProviderContext({ cwd, client });
+    const context = loaded.ok ? loaded.value.context : loaded.context;
+    if (!hasResolvedPlatformContext(context) || !loaded.ok)
         return context;
-    const result = listRemoteComments(client, context.platform.repository, issue, cwd);
-    if (!result.ok) {
-        return platformResult(result.error.retryable ? 'blocked' : 'failed', {
-            ...contextFields(context), resource: { kind: 'issue', number: issue }, error: result.error
+    let identity;
+    try {
+        identity = loaded.ok ? providerResourceToken(loaded.value.provider, 'issue', String(issue)) : null;
+    }
+    catch (error) {
+        return platformResult('failed', { ...contextFields(context), error: { code: 'PLATFORM_IDENTITY_TOKEN_INVALID', message: error instanceof Error ? error.message : String(error), retryable: false } });
+    }
+    if (!loaded.ok || !identity)
+        return context;
+    const listed = loaded.value.provider.comments?.list
+        ? await loaded.value.provider.comments.list({ context: providerOperationContext(loaded.value), parent: identity }).then((response) => response.ok
+            ? { ok: true, value: response.value.map((comment) => ({ id: comment.id, body: comment.body, user: comment.author?.name ? { login: comment.author.name } : undefined })) }
+            : response)
+        : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
+    if (!listed.ok) {
+        return platformResult(providerStatus(listed.error), {
+            ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(identity), identity }, error: providerError(listed.error, 'PLATFORM_PROVIDER_OPERATION_FAILED')
         });
     }
-    return { ...platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: issue }, error: null }), comments: result.value };
+    return { ...platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(identity), identity }, error: null }), comments: listed.value };
 }
-function checkPlatformCommentOwner(taskRef, options = {}) {
+async function checkPlatformCommentOwner(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
     if (!resolved.ok)
         return platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } });
     const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    const issue = issueNumberFromTask(content);
-    if (!issue)
-        return platformResult('no-op', { error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid issue_number', retryable: false } });
-    const client = options.client || createGitHubClient();
-    const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
-    if (!hasResolvedPlatformContext(context))
+    let issueIdentity;
+    try {
+        issueIdentity = taskIssueIdentity(parseTaskFrontmatter(content), undefined, options.runtimeVersion);
+    }
+    catch (error) {
+        return platformResult('failed', { error: { ...taskIssueIdentityError(error), retryable: false } });
+    }
+    if (!issueIdentity)
+        return platformResult('no-op', { error: { code: 'ISSUE_NOT_LINKED', message: 'Task has no valid platform issue identity', retryable: false } });
+    const loaded = await resolvePlatformProviderContext({ cwd: resolved.repoRoot, client: options.client });
+    const context = loaded.ok ? loaded.value.context : loaded.context;
+    if (!hasResolvedPlatformContext(context) || !loaded.ok)
         return context;
-    const listed = listRemoteComments(client, context.platform.repository, issue, resolved.repoRoot);
+    const listed = loaded.value.provider.comments?.list
+        ? await loaded.value.provider.comments.list({ context: providerOperationContext(loaded.value), parent: issueIdentity }).then((response) => response.ok
+            ? { ok: true, value: response.value.map((comment) => ({ id: comment.id, body: comment.body, user: comment.author?.name ? { login: comment.author.name } : undefined })) }
+            : response)
+        : unsupportedProviderOperation(loaded.value.provider, 'comments.list');
     if (!listed.ok)
         return platformResult(listed.error.retryable ? 'blocked' : 'failed', { ...contextFields(context), error: listed.error });
     const matches = findMarkerComments(listed.value, MARKERS.task(resolved.taskId));
@@ -401,11 +454,11 @@ function checkPlatformCommentOwner(taskRef, options = {}) {
     if (owner && owner !== context.platform.currentUser && !context.capabilities.triage) {
         return platformResult('blocked', {
             ...contextFields(context),
-            resource: { kind: 'issue', number: issue },
+            resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentity), identity: issueIdentity },
             error: { code: 'COMMENT_OWNER_CONFLICT', message: `Task comment is owned by '${owner}'`, retryable: false }
         });
     }
-    return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: issue }, error: null });
+    return platformResult('no-op', { ...contextFields(context), resource: { kind: 'issue', number: resourceIdentityNumber(issueIdentity), identity: issueIdentity }, error: null });
 }
 export { MARKERS, chunkArtifactComment, findMarkerComments, listRemoteComments, checkPlatformCommentOwner, listPlatformComments, normalizeCommentContent, renderTaskComment, syncPlatformComment, validateRelatedMarkerSet, writeComment };
 //# sourceMappingURL=issue-comments.js.map